•   상한, 하한이 있는 문제 (sum은 중간에 0 에서 20 사이를 벗어나면 안되었다.)
  •   이것 때문에 dp 시작을 idx = 0, sum = 0 에서 하면 안되고 idx = 0 에서는 무조건 더하기만 가능했기 때문에 이를 구현하기 위해서 시작을 idx = 1, sum = tb1[0] 으로 해주어야 했다.
  •    1차원 cache로 구현하려고 오랫동안 고민했는데 ( 2차원으로 하는 문제란 걸 모르고 ) 2차원 배열로 sum의 경우까지 구분해 주어야 하는 것을 생각하지 못했었다. 질문 보기를 통해 알았다. idx 만으로 구분하기엔 뭔가 찜찜한 느낌은 있었는데 제대로 안 것 같다. 

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <limits.h>

using namespace std;

typedef long long ull;

int n;
int tb1[111];
ull che1[110][21];

ull go(int idx, int sum){
    if(idx == n-1 && sum == tb1[idx]){
        return 1;
    }
    else if(idx == n-1){
        return 0;
    }
    if(sum > 20){
        return 0;
    }
    if(sum < 0){
        return 0;
    }

    ull& ret = che1[idx][sum];
    if(ret != -1){
        return ret;
    }
    ret = 0;
    ret = go(idx+1,sum+tb1[idx]) + go(idx+1,sum-tb1[idx]);
    return ret;
}

int main(void){
    memset(che1,-1,sizeof(che1));
    cin >> n;
    for(int i=0;i<n;++i){
        cin >> tb1[i];
    }
    cout << go(1,tb1[0]) << endl;
    
    return 0;
}




tb배열은 왜만들었는지 모르겠다. 
몽롱해서 막 코딩했는데 되게 안됐다. 
삽질하느라 디버깅한다고 che2를 매번 확인하면서 깨달은게 있다.
che2배열은 0,0쪽에 결과가 더해져서 return 한다는 것. 

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <limits.h>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
int dx[] = { 0,1 };
int dy[] = { 1,0 };
//int tb1[100001];
ll tb2[20][20];
//int che[100001];
ll che2[20][20];
//int sum[1001];
int n, m;
//int min3(int a,int b,int c){
//     a = (a < b ? a : b);
//     return (a < c ? a : c);
//}
int aaa, bbb;
ll go(int s, int e, int fx, int fy) {
       if (che2[s][e] != -1) {
              return che2[s][e];
       }
       if (s == fx && e == fy) {
              return che2[s][e] = 1;
       }
       che2[s][e] = 0;
       ll& ret = che2[s][e];
       for (int k = 0; k < 2; ++k) {
              int nx = dx[k] + s;
              int ny = dy[k] + e;
              if (aaa <= nx && nx <= fx && bbb <= ny && ny <= fy) {
                     ret += go(nx, ny, fx, fy);
              }
       }
       return ret;
}
int main(void)
{
       int n, m,k;
       cin >> n >> m >> k;
       int a, b;
       bool ans_is_easy = false;
       if (k == 0) {
              ans_is_easy = true;
       }
       for (int i = 1; i <= n; ++i) {
              for (int j = 1; j <= m; ++j) {
                     tb2[i][j] = (i - 1)*m + j;
                     if ((i-1)*m+j == k && ans_is_easy == false) {
                           a = i, b = j;
                     }
              }
       }
       
       //cout << "a b " << a << ' ' << b << endl;
       aaa = 1;
       bbb = 1;
       memset(che2, -1, sizeof(che2));
       ll kk;
       if (!ans_is_easy) {
              kk = go(1, 1, a, b);
       }
       /*for (int i = 1; i <= n; ++i) {
              for (int j = 1; j <= m; ++j) {
                     cout << che2[i][j] << ' ';
              }
              cout << endl;
       }*/
       memset(che2, -1, sizeof(che2));
       ll kkk;
       if (ans_is_easy) {
              cout << go(1, 1, n, m);
              return 0;
       }
       else {
              aaa = a;
              bbb = b;
              kkk = go(a, b, n, m);
       }
       //for (int i = 1; i <= n; ++i) {
       //     for (int j = 1; j <= m; ++j) {
       //            cout << che2[i][j] << ' ';
       //     }
       //     cout << endl;
       //}
       cout << kk * kkk;
       
       return 0;
}


'알고리즘' 카테고리의 다른 글

[DP] 백준 2631 줄세우기  (0) 2018.04.29
[DP] 백준 5557 1학년  (0) 2018.04.29
[DP] 백준 1915 가장 큰 정사각형 만들기  (0) 2018.04.29
[DP] 백준 9461 파도반 수열  (0) 2018.04.29
[DP] 백준 2098 외판원순회  (0) 2018.04.29

참고한 블로그
그림을 보니까 이해가 됐다. 

입력받은 양의 공간만 사용해서 dp를 한게 아니라 필요에 따라 좀더 늘려서 할 수 있다는 걸 보여준 문제
ex. i,j == 1부터 입력받고 탐색은 i-1로 0부터 탐색한다. ==> 여기엔 자동으로 값이 0이 저장된 걸 이용

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <limits.h>
#include <queue>
#include <stack>
int min3(int a,int b,int c){
       a = (a < b ? a : b);
       return (a < c ? a : c);
}
using namespace std;
int tb1[100001];
int tb2[1001][1001];
int che[100001];
int che2[1001][1001];
bool doo[100001];
int n, m;
int main(void)
{
       cin >> n >> m;
       for (int i = 1; i <= n; ++i) {
              for (int j = 1; j <= m; ++j) {
                     scanf_s("%1d", &tb2[i][j]);
              }
       }
       int ans = 0;
       for (int i = 1; i <= n; ++i) {
              for (int j = 1; j <= m; ++j) {
                     if (tb2[i][j] == 1) {
                           che2[i][j] = min3(che2[i - 1][j - 1], che2[i - 1][j], che2[i][j - 1]) + 1;
                           ans = (ans < che2[i][j] ? che2[i][j] : ans);
                     }
              }
       }
       cout << ans*ans << endl;
       
       return 0;
}


'알고리즘' 카테고리의 다른 글

[DP] 백준 5557 1학년  (0) 2018.04.29
[DP] 백준 10164 격자상의경로  (0) 2018.04.29
[DP] 백준 9461 파도반 수열  (0) 2018.04.29
[DP] 백준 2098 외판원순회  (0) 2018.04.29
[DP] 백준 4811 알약  (0) 2018.04.29


#include <iostream>

using namespace std;
int d[101];
int main() {
       d[2]=d[3]=d[1] = 1;
       d[4] = d[5] = 2;
       
       for (int i = 6; i < 101; ++i) {
               d[i] = d[i - 1] + d[i - 5];
       }
       int t;
       cin >> t;
       while (t--) {
               int k;
               cin >> k;
               cout << d[k] << '\n';
       }
               
       return 0;
}



풀이

=> 1번 삼각형부터 차례대로 번호를 매기며 값을 나열해봤다. 

그 과정에서 6번째 삼각형은 5번째 삼각형의 변과 1번째 삼각형의 변으로 이루어져 있다는 것을 확인할 수 있었다.

그대로 점화식을 세우고 나열하였다. 


'알고리즘' 카테고리의 다른 글

[DP] 백준 10164 격자상의경로  (0) 2018.04.29
[DP] 백준 1915 가장 큰 정사각형 만들기  (0) 2018.04.29
[DP] 백준 2098 외판원순회  (0) 2018.04.29
[DP] 백준 4811 알약  (0) 2018.04.29
[DP] 백준 11048 이동하기  (0) 2018.04.29

  • 코드 질문하기에서 배꼈는데 종만북과 거의 유사한 형태의 코드. 비트마스크로 state를 아름답게 표현
  • 외워도 좋을 것 같다.
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstring>
#include <stack>
#include <queue>
#include <limits.h>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;

const int INF = 987987987;

int n;
int pivot;
int tb1[100001];
int tb2[16][16];
int che2[16][1<<16];
int che1[100001];

int go(int idx, int state){
    if((state & (1<<pivot)) && state != (1 << n) - 1) return INF; // state와 pivot이 중복되면서 state가 완전히 탐색한 상태가 아닐 때 INF
    if(state == (1<<n) - 1) return 0;
    int& ret = che2[idx][state];
    if(ret != -1) return ret;

    ret = INF;
    for(int i=0;i<n;++i){
        if(tb2[idx][i] > 0 && !(state&(1<<i))){
            ret = min(ret, go(i,state | (1<<i)) + tb2[idx][i]);
        }
    }
    return ret;
}

int main(void){
    cin >> n;
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            cin >> tb2[i][j];
        }
    }
    int ans = INF;
    for(int i=0;i<n;++i){
        memset(che2,-1,sizeof(che2));
        pivot = i;
        ans = min(ans, go(i,0));
    }
    cout << ans << endl;
    return 0;
}



'알고리즘' 카테고리의 다른 글

[DP] 백준 1915 가장 큰 정사각형 만들기  (0) 2018.04.29
[DP] 백준 9461 파도반 수열  (0) 2018.04.29
[DP] 백준 4811 알약  (0) 2018.04.29
[DP] 백준 11048 이동하기  (0) 2018.04.29
[DP] 백준 10211 Maximum subarray  (0) 2018.04.29



알약 성공


시간 제한
메모리 제한
제출
정답
맞은 사람
정답 비율
1 초
128 MB
1113
611
444
58.653%

문제
70세 박종수 할아버지는 매일 매일 약 반알을 먹는다. 손녀 선영이는 종수 할아버지에게 약이 N개 담긴 병을 선물로 주었다.
첫째 날에 종수는 병에서 약 하나를 꺼낸다. 그 다음, 그 약을 반으로 쪼개서 한 조각은 먹고, 다른 조각은 다시 병에 넣는다.
다음 날부터 종수는 병에서 약을 하나 꺼낸다. (약은 한 조각 전체 일 수도 있고, 쪼갠 반 조각 일 수도 있다) 반 조각이라면 그 약을 먹고, 아니라면 반을 쪼개서 한 조각을 먹고, 다른 조각은 다시 병에 넣는다.
종수는 손녀에게 한 조각을 꺼낸 날에는 W를, 반 조각을 꺼낸 날에는 H 보낸다. 손녀는 할아버지에게 받은 문자를 종이에 기록해 놓는다. 총 2N일이 지나면 길이가 2N인 문자열이 만들어지게 된다. 이 때, 가능한 서로 다른 문자열의 개수는 총 몇 개일까?
입력
입력은 최대 1000개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스는 한 줄이며, 병에 들어있는 약의 개수 N ≤ 30 가 주어진다.
입력의 마지막 줄에는 0이 하나 주어진다.
출력
각 테스트 케이스에 대해서 가능한 문자열의 개수를 출력한다.
예제 입력 1 
6
1
4
2
3
30
0
예제 출력 1 
132
1
14
2
5
3814986502092304






















































#include <iostream>
#include <cstring>
using namespace std;
int n;
long long cache[32][32];
long long go(long long wcnt, long long hcnt) {
       if (cache[wcnt][hcnt] != -1) {
              return cache[wcnt][hcnt];
       }
       long long &ret = cache[wcnt][hcnt];
       if (wcnt < hcnt) {
              ret = 0;
              return ret;
       }
       if (wcnt > n) {
              ret = 0;
              return ret;
       }
       if (hcnt > n) {
              ret = 0;
              return ret;
       }
       if (wcnt + hcnt >= n * 2) {
              return 1;
       }
       ret = go(wcnt + 1, hcnt) + go(wcnt, hcnt + 1);
       return ret;
}
int main(void)
{
       long long hcnt = 0, wcnt = 0;
       while (cin >> n && n != 0) {
              memset(cache, -1, sizeof(cache));
              cout << go(wcnt, hcnt) << endl;
       }
}

















'알고리즘' 카테고리의 다른 글

[DP] 백준 9461 파도반 수열  (0) 2018.04.29
[DP] 백준 2098 외판원순회  (0) 2018.04.29
[DP] 백준 11048 이동하기  (0) 2018.04.29
[DP] 백준 10211 Maximum subarray  (0) 2018.04.29
[DP] 백준 1495 기타리스트  (0) 2018.04.29

누적하기
#include <iostream>
#include <algorithm>
#include <cstring>
#include <limits.h>
#include <stack>
using namespace std;
int table[1001][1001];
int cache[1001][1001];
int dx[] = { 1,0,1 };
int dy[] = { 0,1,1 };
int n, m;
int go(int x, int y) {
       //cout << "root : " << table[x][y] << endl;
       if (cache[x][y] != -1) {
              return cache[x][y];
       }
       cache[x][y] = table[x][y];
       int& ret = cache[x][y];
       for (int k = 0; k < 3; ++k) {
              int nx = x + dx[k];
              int ny = y + dy[k];
              if (0 <= nx && nx < n && 0 <= ny && ny < m) {
                     ret = max(ret,go(nx, ny)+table[x][y]);   
                     
              }
       }
       return ret;
}
int main(void) {
       memset(cache, -1, sizeof(cache));
       cin >> n >> m;
       for (int i = 0; i < n; ++i) {
              for (int j = 0; j < m; ++j) {
                     cin >> table[i][j];
              }
       }
       
       cout << go(0, 0);
       return 0;
}


'알고리즘' 카테고리의 다른 글

[DP] 백준 2098 외판원순회  (0) 2018.04.29
[DP] 백준 4811 알약  (0) 2018.04.29
[DP] 백준 10211 Maximum subarray  (0) 2018.04.29
[DP] 백준 1495 기타리스트  (0) 2018.04.29
[DP] 백준 2240 자두나무  (0) 2018.04.29

재귀로 풀고싶었으나 안되었다.
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>

using namespace std;

typedef long long ll;
ll tb1[100001];
ll che1[100001];
ll n;
ll maxnum = -1;

int main(void)
{
    int t;
    cin >> t;
    while(t--){
        memset(che1,-1,sizeof(che1));
        memset(tb1,0,sizeof(tb1));
        maxnum = -1;
        cin >> n;
        for(int i=0;i<n;++i){
            cin >> tb1[i];
        }
        che1[0] = tb1[0];
        maxnum = tb1[0];
        for(int i=1;i<n;++i){
            che1[i] = max(tb1[i],che1[i-1]+tb1[i]);
            maxnum = max(maxnum,che1[i]);
        }
        cout << maxnum << endl;
    }
    return 0;
}


'알고리즘' 카테고리의 다른 글

[DP] 백준 4811 알약  (0) 2018.04.29
[DP] 백준 11048 이동하기  (0) 2018.04.29
[DP] 백준 1495 기타리스트  (0) 2018.04.29
[DP] 백준 2240 자두나무  (0) 2018.04.29
[DP] 백준 2302 극장 좌석  (0) 2018.04.29


/*
       중요했던 점.
       경우의 수는 4가지가 있다.
       1. 더하고 빼고 둘다 s,m 범위 에 들어가는 것
       2,3 더하기만 들어가는 경우, 빼기만 들어가는 경우
       4. 둘다 안들어 가는 경우 => 불가능한 경우
       알게 모르게 4번 경우를 따로 return 값을 지정해 주지 않아
       -1이란 값을 방문하지 않았다는 의미로 사용하려고 초기화 했는데 불가능한 의미와 중복으로 사용되어 버렸다.
       따라서 4번 경우가 있었을 때 무한루프에 빠질 수 있다. 혹은 제대로 된 메모리제이션이 불가능하다.
       4번 경우를 따로 값을 지정해 주어 의미를 다르게 하니 정상적으로 돌아갔다.
       참고한 답변
       Hibbah   2년 전    1 좋아요
       저도 방금 시간초과를 받았는데 같은 실수를 하셨네요.
       메모이제이션 테이블인 DP[][]에서 '아직 계산한 적이 없다.'라는 의미의 초기값을 -1로 해두셨는데,
       작성하신 코드를 보시면 반환 값 -1이 '마지막 곡을 부를 때 가능한 볼륨 값이 0~M사이에 존재하지 않는다.'라는 의미와 중복됨을 알 수 있습니다.
       예를 들어, N=100인 상황에서 현재 재귀함수의 매개변수가 X=20, Y=30이라 하고,
       현재상태에서 끝까지 볼륨조절을 어떻게 하더라도 마지막 곡을 부를때 가능한 볼륨 값이 허용 범위를 벗어난다고 가정하겠습니다.
       그러면 X=20에서 N=100까지의 무수히 많은 경우의 수에 대해 제법 깊은 재귀함수의 탐색 과정을 통해 -1을 반환하여
       DP[20][30]에는 '현재 볼륨이 30이고, 20번째 곡의 볼륨을 조절하여 마지막 곡 까지 불렀을 때' 가능한 볼륨 값이 없다는 의미로 -1이 할당되게 됩니다.
       그런데 이는 '20번째 곡을 부르기 직전에 볼륨이 30일 경우에 대해서는 계산을 해본 적이 한 번도 없다'라는 의미와 중복되므로,
       X=0 ~ 20까지의 볼륨 조절 조합으로 Y=30이 되는 모든 경우에 대해 X = 20 ~ 100까지의 굉장히 많은 탐색 공간을 매번 중복해서 계산하게 됩니다.
       .......
       간략하게 적어도 이해하실 내용을 적다보니 너무 장황하게 적은것 같네요
       결론은 '계산한 적 없다'와 '불가능하다'의 의미를 구분하도록 다른 값을 할당하시면 될 것 같습니다.
       좋은하루되십셔 ㅎ, ㅎ
*/
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
int tb1[1001];
int cache[2001][2001];
int n, s, m;
bool finish = false;
int maxv = 0;
int go(int cnt, int cur_val) {
       if (cnt == n) {
               finish = true;
               maxv = max(cur_val, maxv);
               return cur_val;
       }
       int& ret = cache[cnt][cur_val];
       if (ret == -9999) {
               return 0;
       }
       if (ret != -1) {
               return ret;
       }
       bool nofirst = false;
       int longhate = cur_val + tb1[cnt];
       if (longhate >= 0 && longhate <= m) {
               ret = go(cnt + 1, cur_val + tb1[cnt]);
       }
       else {
               nofirst = true;
       }
       longhate = cur_val - tb1[cnt];
       if (longhate >= 0 && longhate <= m){
               ret = go(cnt + 1, cur_val - tb1[cnt]);
       }
       else {
               if (nofirst == true) {
                      ret = -9999; // 불가능
               }
       }
       return ret;
}
int main(void) {
       memset(cache, -1, sizeof(cache));
       cin >> n >> s >> m; // m은 최대 볼륨
       for (int i = 0; i < n; ++i) {
               cin >> tb1[i];
       }
       int ans = go(0,s);
       if (finish) {
               cout << maxv << '\n';
       }
       else {
               cout << -1 << endl;
       }
       return 0;
       
}


'알고리즘' 카테고리의 다른 글

[DP] 백준 11048 이동하기  (0) 2018.04.29
[DP] 백준 10211 Maximum subarray  (0) 2018.04.29
[DP] 백준 2240 자두나무  (0) 2018.04.29
[DP] 백준 2302 극장 좌석  (0) 2018.04.29
[DP] 백준 1932 숫자삼각형  (0) 2018.04.29


#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
int tb1[1001];
int cache[1001][1001][2];
int n, m;
int go(int idx,int tree,int changecnt) {
       if (idx >= n) {
               return 0;
       }
       if (changecnt > m) {
               return 0;
       }
       
       int& ret = cache[idx][changecnt][tree];
       if (ret != -1) {
               return ret;
       }
       int val = (tb1[idx] == tree ? 1 : 0);
       
       ret = max(go(idx + 1, tree, changecnt), go(idx + 1, 3 - tree, changecnt + 1)) + val;
       return ret;
}
int main(void) {
       memset(cache, -1, sizeof(cache));
       cin >> n >> m;
       for (int i = 1; i <= n; ++i) {
               cin >> tb1[i];
       }
       tb1[0] = 0; // i = 0부터 해서 이 코드를 넣지 않으면 시작하자마자 이동할 수 있는 경우를 생각해 주지 못한다.
       cout << go(0, 1, 0) << endl;
       
       return 0;
       
}


'알고리즘' 카테고리의 다른 글

[DP] 백준 10211 Maximum subarray  (0) 2018.04.29
[DP] 백준 1495 기타리스트  (0) 2018.04.29
[DP] 백준 2302 극장 좌석  (0) 2018.04.29
[DP] 백준 1932 숫자삼각형  (0) 2018.04.29
[DP] 백준 14501 퇴사  (0) 2018.04.29

+ Recent posts