#include <stdio.h>
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <map>
#include <string>
#include <string.h>
using namespace std;
 
int row, col, K;
char Map[110][110];
int dp[110][110][90];
string word;
int ans;
 
int dx[4= {-1100};
int dy[4= {00-11};
 
int safe(int x, int y)
{
    if(x >= 0 && x < row && y >= 0 && y < col)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
int DFS(int x, int y, int idx)
{
    if(Map[x][y] == word[idx] && idx == word.size()-1)
    {
        return 1;
    }
    
    // dp[x][y][idx] != 0 이면 시간초과 -> dp[x][y][idx] = 0 인 경우에는 어차피 더 찾아도 없음을 뜻함 중요.. 
    if(dp[x][y][idx] != -1)
    {
        return dp[x][y][idx];
    }
    
    dp[x][y][idx] = 0
    
    for(int i = 0; i < 4; i++)
    {
        for(int j = 1; j <= K; j++)
        {
            int xpos = x + (dx[i] * j);
            int ypos = y + (dy[i] * j);    
            int nIdx = idx + 1;    
            
            if(safe(xpos, ypos) == 1 && Map[xpos][ypos] == word[nIdx])
            {
                dp[x][y][idx] += DFS(xpos, ypos, nIdx);
            }
        }
    }
    
    return dp[x][y][idx];
}
 
int main(void)
{
//    freopen("B2186_input.txt", "r", stdin);
    
    cin >> row >> col >> K;
    
    for(int i = 0; i < row; i++)
    {
        string temp;
        cin >> temp;
        
        for(int j = 0; j < temp.size(); j++)
        {
            Map[i][j] = temp[j];
        }
    }
    
    cin >> word;
    
    memset(dp, -1sizeof(dp));
    
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            if(Map[i][j] == word[0])
            {
                ans += DFS(i, j, 0);
            }
        }
    }
    
    cout << ans;
    
    return 0;
}
cs
#include <iostream>
#include <algorithm>
#include <queue>
#include <string.h>
using namespace std;
 
int map[510][510];
int dp[510][510];
int row, col;
 
int dx[4= {-1100};
int dy[4= {00-11};
 
int safe(int x, int y)
{
    if(x >= 0 && y >= 0 && x < row && y < col)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
int DFS(int x, int y)
{
    if(x == row-1 && y == col-1)
    {
        return 1;
    }
    
    if(dp[x][y] != -1)
    {
        return dp[x][y];
    }
    
    dp[x][y] = 0;
    
    for(int i = 0; i < 4; i++)
    {
        int xpos = x+dx[i];
        int ypos = y+dy[i];
        
        if(safe(xpos, ypos) == 1)
        {
            if(map[x][y] > map[xpos][ypos])
            {
                dp[x][y] += DFS(xpos, ypos);
            }
        }
    }
    
    return dp[x][y];
}
 
int main(void)
{
//    freopen("B1520_input.txt", "r", stdin);
 
    cin >> row >> col;
 
    for(int i = 0; i < row; i++)
    {
        for(int j = 0; j < col; j++)
        {
            cin >> map[i][j];
            dp[i][j] = -1;
        }
    }
    
    cout << DFS(00);
    
    return 0;
}
cs
#include <iostream>
#include <algorithm>
#include <queue>
#include <string.h>
using namespace std;
 
int N;
int map[510][510];
int dp[510][510];
int Max;
 
int dx[4= {-1100};
int dy[4= {00-11};
 
int safe(int x, int y)
{
    if(x >= 0 && y >= 0 && x < N && y < N)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
int DFS(int x, int y)
{
    if(dp[x][y] != 0)
    {
        return dp[x][y];
    }
    
    dp[x][y] = 1;
    
    for(int i = 0; i < 4; i++)
    {
        int xpos = x+dx[i];
        int ypos = y+dy[i];
        
        if(safe(xpos, ypos) == 1)
        {
            if(map[x][y] < map[xpos][ypos])
            {
                dp[x][y] = max(dp[x][y], DFS(xpos, ypos) + 1);
            }
        }
    }
    
    return dp[x][y];
}
 
int main(void)
{
//    freopen("B1937_input.txt", "r", stdin);
    
    cin >> N;
 
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            cin >> map[i][j];
        }
    }
    
    for(int i = 0; i < N; i++)
    {
        for(int j = 0; j < N; j++)
        {
            Max = max(Max,  DFS(i, j));
        }
    }
    
    cout << Max;
    
    return 0;
}
 
cs
#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
 
int N;
int dp[100010][3]; // 0(사자X), 1(사자 왼쪽), 2(사자 오른쪽)
 
int solve(int row, int status)
{
    if(row == N)
    {
        return 1;
    }
    
    if(dp[row][status] !=0)
    {
        return dp[row][status];
    }
    
    if(status == 0)
    {
        dp[row][status] += (solve(row+10+ solve(row+11+ solve(row+12)) % 9901;        
    }
    else if(status == 1)
    {
        dp[row][status] += (solve(row+10+ solve(row+12)) % 9901;        
    }
    else if(status == 2)
    {
        dp[row][status] += (solve(row+10+ solve(row+11)) % 9901;    
    }
    
    return dp[row][status] % 9901;
}
 
int main(void)
{
//    freopen("B1309_input.txt", "r", stdin);
    
    cin >> N;
    
    cout << solve(00);
    
    return 0;
}
cs
#include <iostream>
#include <algorithm>
using namespace std;
 
int N;
int arr[1010];
int dp[1010];
int Max;
 
int solve(int cnt)
{
    if(dp[cnt] != 0)
    {
        return dp[cnt];
    }
    
    dp[cnt] = 1;
 
    for(int i = cnt-1; i >= 1; i--)
    {
        if(arr[cnt] > arr[i])
        {
            dp[cnt] = max(dp[cnt], solve(i) + 1);
        }
    }
    
    return dp[cnt];
}
 
int main(void)
{
//    freopen("B1965_input.txt", "r", stdin);
    
    cin >> N;
    
    for(int i = 1; i <= N; i++)
    {
        cin >> arr[i];
    }
    
    for(int i = N; i >= 1; i--)
    {
        Max = max(Max, solve(i));
    }
    
    cout << Max;
    
    return 0;
}
cs
#include <iostream>
#include <string>
#include <string.h>
#include <algorithm>
using namespace std;
 
string A, B;
int dp[1010][1010];
string result;
 
int solve(int aIdx, int bIdx)
{
    if(aIdx == A.size() || bIdx == B.size())
    {
        return 0;
    }
    
    if(dp[aIdx][bIdx] != 0)
    {
        return dp[aIdx][bIdx];
    }
    
    if(A[aIdx] == B[bIdx])
    {
        dp[aIdx][bIdx] = solve(aIdx+1, bIdx+1+ 1;
    }
    else
    {
        dp[aIdx][bIdx] = max(solve(aIdx+1, bIdx), solve(aIdx, bIdx+1));
    }
    
    return dp[aIdx][bIdx];
}
 
int main(void)
{
//    freopen("B9252_input.txt", "r", stdin);
    
    cin >> A >> B;
    
    cout << solve(00<< endl;
 
    int aIdx = 0;
    int bIdx = 0;
    while(dp[aIdx][bIdx] != 0)
    {
        if(dp[aIdx][bIdx] == dp[aIdx+1][bIdx])
        {
            aIdx++;
        }
        else if(dp[aIdx][bIdx] == dp[aIdx][bIdx+1])
        {
            bIdx++;
        }
        else if(dp[aIdx][bIdx]-1 == dp[aIdx+1][bIdx+1])
        {
            result += A[aIdx];
            aIdx++;
            bIdx++;
        }
    }
    
    cout << result << endl;
    
    return 0;
}
cs
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
using namespace std;
 
string A, B;
int dp[1010][1010];
int Max;
 
int solve(int aIdx, int bIdx)
{
    if(aIdx == A.size() || bIdx == B.size())
    {
        return 0;    
    }    
    
    if(dp[aIdx][bIdx] != 0)
    {
        return dp[aIdx][bIdx];
    }
 
    if(A[aIdx] == B[bIdx])
    {
        dp[aIdx][bIdx] = solve(aIdx+1, bIdx+1+ 1;
    }
    else
    {
        dp[aIdx][bIdx] = max(solve(aIdx+1, bIdx), solve(aIdx, bIdx+1));
    }
    
    return dp[aIdx][bIdx];
}
 
int main(void)
{
//    freopen("B9251_input.txt", "r", stdin);
    
    cin >> A >> B;
    
    cout << solve(00);
    
    return 0;
}
cs
#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
 
int N, M;
int dp[310];
 
int solve(int n, int m)
{
    if(n == 1)
    {
        return m-1;    
    }    
    
    if(dp[n] != 0)
    {
        return dp[n];
    }
 
    if(n % 2 == 0)
    {
        dp[n] += solve(n/2, m) + solve(n/2, m) + 1;
    }
    else
    {
        dp[n] += solve(n/2, m) + solve(n/2+1, m) + 1;
    }
    
    return dp[n];
}
 
int main(void)
{
//    freopen("B2163_input.txt", "r", stdin);
    
    cin >> N >> M;
    
    cout << solve(N, M);
    
    return 0;
}
cs

+ Recent posts