문제 링크 : https://www.acmicpc.net/problem/1699


해결 방법 :


이 문제는 다이나믹 프로그래밍 문제다.


그렇기 때문에 먼저,


우리가 구하고자 하는 문제가 뭔지 본다. 


문제는 주어진 자연수 N을 제곱수들의 합으로 표현할 때에 그 항의 최소개수 이다. 


ex) N = 3  , 1^2 + 1^2 + 1^2 = 3개 

    N = 7,  3^2 + 1^2 + 1^2 = 3개


나는 처음에 접근한 방법이 제곱을 했을때 (N 과 가장 가까운 수에 대해 최소항의 개수  + N- 가장가까운수 에대한 최소항의 개수) 로 점화식을 세워서 풀었었다. 하지만 이는 12를 구할때 깨져버린다. 

위점화식을 적용해보면, 9의 최소항의개수 + 12-9의 최소항의개수 = 4가 나오게 된다.

2^2 + 2^2 + 2^2 = 3개 이것이 최소개수인데 말이다. ㅜㅜ


다시 생각해 본 후 , 모든 경우를 고려하면 답을 구할수 있다고 봣다.

즉, 어떤 수 12는  제곱의 합에서 1의 제곱이 포함됬다고 보면 11의 최소항의개수 + 1 이 될것이다. 여기서 +1 은 1의 제곱이 포함됬기 때문이다.

12는 또 제곱의 합에서 2의제곱이 포함됬다고 보면 10의 최소항의 개수 + 1 이 된다.

12는 또 제곱의 합에서 3의 제곱이 포함됬다고 보면 9의 최소항의 개수 + 1이 된다.



이렇게 모든 경우를 포함하는 점화식을 세운다면 DP[N] = MIN ( DP[N], DP[N-j의제곱] + 1)  이될것이다.

(이때, j는 제곱해서 N보다 같거나 작을때까지의 수를 반복해서 도는 경우이다.)




반응형

'PS > 백준' 카테고리의 다른 글

1932번 정수삼각형  (0) 2018.12.30
1149번 RGB거리  (0) 2018.12.05
7490번 0 만들기  (0) 2018.12.05
1003번 피보나치 함수  (0) 2018.12.02
1065번 한수  (0) 2018.11.16

문제링크)

http://codeup.kr/problem.php?id=3733


해결방법)


어떤 임의의 자연수 n 을 입력받고 홀수 or 짝수 일때의 각각의 규칙에 따라 재귀함수를 호출한다.

이때 재귀함수 호출 횟수가 몇번인지가 문제에서 말한 우박수의 길이가 되고 이것을 구하면 된다.


규칙은 다음과 같다.

1. 어떤 자연수 n이 입력되면,

2. n이 홀수이면 3n+1을 하고,

3. n이 짝수이면 n/2를 한다.

4. 이 n이 1이 될때까지 2~3과정을 반복한다.

예를 들어 5는 5 → 16 → 8 → 4 → 2 → 1 이 된다.

여기서 생각해야할 부분이 있는데, 입력이 자연수 a, b 구간으로  1<= a <= b <= 10,000,000 의 아주 큰 범위를 갖는다.

그래서 이 문제가 large 버전으로 이름이 붙여진 것 같다.

이 큰 값의 범위 입력을 풀기 위해서 대표적인 방법으로 메모이제이션을 써서 시간복잡도를 줄여야 겠다는 생각을 했다.

그리고 코딩하면서 알게 된것이 배열을 천만으로 선언할 수 있다는 것을 알 수 있었다. 너무 비효율적이라 생각되는데 무튼 문제만 푼다면야...하고 일단 넘어가자.


메모이제이션을 할때 천만으로만 하기 때문에 n이 홀수여서 천만의 값을 넘어간다면 이는 따로 조건을 추가해서 메모이제이션을 안하고 다음 재귀함수를 그냥 호출 하는 방식으로 구해보았다.



반응형

'PS > 코드업' 카테고리의 다른 글

3704번 계단 오르기 2  (0) 2019.03.31
1920번 2진수 변환 (재귀함수)  (0) 2019.03.16
2606. 소수점 이하 출력  (0) 2018.12.17
재귀함수 1부터 n까지 합 구하기  (0) 2018.11.18
코드업-캔디팡 문제  (0) 2018.09.23

문제 링크 : https://www.acmicpc.net/problem/1932


해결 방법 :


제일 단순하게 처음 시도했던 방법은 완전탐색으로 왼쪽합누적, 오른쪽 합누적 하는 방법으로 n번째 줄까지 전부 구했었다.



그리고 n번째줄에서 모든 합들을 비교해서 최대값을 찾아서 출력했었는데, 시간초과로 틀렸었다. 알고보니 2의 n승의 시간복잡도....ㅜ



그래서 다이나믹프로그래밍의 메모이제이션 기법을 사용해야겠다는 생각을 했다. 왜냐 시간초과니까 ㅜ

시간을 줄일방법을 생각해보니까 재귀를 줄여야겠다고 생각했다.

재귀를 줄이려면 각각의 요소가 최대값을 가져야했고 그거를 재호출했을때 미리 저장해놓은 최대값을 툭 내뱉어버리면 다시 재귀호출을 안할수 있다고 생각했다.


그래서 n번째 줄에서 부터 거꾸로 찾아나갔다. (top-down 방식)

n번째줄의 i번째 요소까지의 최대값은 max(n-1번째줄의 i번째 최대값, n-1번째줄의 i-1번쨰 최대값) + n번쨰줄의 i번째요소값 의 점화식으로 구할 수 있었다.

그리고 이를 기록해야한다. 왜? 재호출 방지위해서

식으로보면, d[x][y] = max(solve(x-1,y), solve(x-1,y-1)) + a[x][y] 이다.


또한, -1은 범위밖에있는 것들을 미리 저장해놔서 그곳에 호출하려하면 0을 리턴한다.  왜냐? 존재하지 않는 값이니까..




반응형

'PS > 백준' 카테고리의 다른 글

1699 제곱수의 합  (0) 2019.05.26
1149번 RGB거리  (0) 2018.12.05
7490번 0 만들기  (0) 2018.12.05
1003번 피보나치 함수  (0) 2018.12.02
1065번 한수  (0) 2018.11.16

문제링크 : https://www.acmicpc.net/problem/7490


해결방법 : 

1 부터  N까지 -, +, " " 의 연산을 사이에 각각 넣어서 최종 합이 0이 되는 식을 모두 출력하는 문제다.

일단 식을 누적하는 변수 str, 최종합을 누적하는 변수 sum을 설정하고 생각해봤다.


자연스레 3가지경우에 대해 재귀호출을 하면 모든 경우를 만들 수 있기에 3가지의 재귀함수를 설계하면 답을 구할 수 있다.


여기서 ""연산에 대해 주의할 점이 있는데, 

다음 재귀에 +나 -를 만나면 이전의 값(num)을 sum에 더해주거나 빼준다. 그전에는 sum에 아무런 계산하지 않는다.

이말은 ""로 된부분은 num에 합쳐진숫자로 업데이트만 하고, 다음에 +나-가 오면 계산을 해준다는 것이다.

나머지 -, +의 경우에는 다음에도 -,+일때 sum에 num*sign 값을 더해준다. 참고로 sign을 곱해주고 더해주면서 뺄셈을 한다. 

재귀함수로 넘겨주는 값을 보면 이해가 될것이다.


소스코드)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include<iostream>
#include<string>
using namespace std;
int N;
void solve(int sum, int sign, int num, int n, string str)
{
    //1부터 N까지 숫자를 3가지연산을 해서 0으로 되는 식을 모두 출력하는 함수
    if (n == N)
    {
        sum += (num * sign);
        if (sum == 0)
        {
            cout << str << '\n';
        }
    }
    else
    {
        solve(sum, sign, num * 10 + (n + 1), n + 1, str + ' ' + char(n + 1 + '0'));
        solve(sum + (sign*num), 1, n + 1, n + 1, str + '+' + char(n + 1 + '0'));
        solve(sum + (sign*num), -1, n + 1, n + 1, str + '-' + char(n + 1 + '0'));
    }
}
int main()
{
    int test_case;
    char test;
    scanf("%d"&test_case);
    for (int i = 0; i < test_case; i++)
    {
        scanf("%d"&N);
        solve(0111"1");// sum, sign, num, n, str
        printf("\n");
    }
    return 0;
}
cs


반응형

'PS > 백준' 카테고리의 다른 글

1932번 정수삼각형  (0) 2018.12.30
1149번 RGB거리  (0) 2018.12.05
1003번 피보나치 함수  (0) 2018.12.02
1065번 한수  (0) 2018.11.16
1110번 더하기 사이클  (0) 2018.11.14

문제 링크 : https://www.acmicpc.net/problem/1003


해결 방법 :

피보나치 함수를 재귀함수, Top-down 방식으로 푼다고 했을 때 fibonacci(0), fibonacci(1) 의 호출 개수를 각각 출력하는 문제다.

처음에는 단순히 

if(n == 0) 일때 0의 카운트 증가,

if(n == 1) 일때 1의 카운트 증가로 바로 풀수가 있었는데 채점해보니 시간초과가 떴다.. ㅋ


아 그러면 익히알고있는 다이나믹프로그래밍으로 메모를 쓰고 읽어서 시간을 줄여야 되는 구나라고 생각했다.


테스트 케이스를 가지고 여러번 하다보니 다음과 같은 규칙을 발견했다.

N의 0호출 개수는 N-1의 1호출 개수라는 것

example)  5의 0의 호출개수 = 4의 1의 호출개수, 다른것도 직접해보면 알것이다.


따라서 N과 N-1의 피보나치함수를 호출하고 N==1일때 1의 카운팅을 리턴하여서 각각 총 1의 호출개수를 각각 구할 수 있었다. 

이때, 재귀함수에서 여러 N의 1의호출개수를 메모로 저장해둬서(d[N]) 시간을 줄였다.


소스코드)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include<stdio.h>
int d[41];
int fibonacci(int n) {
   if(n == 0)
   {
        return 0;
   }
   else if(n==1)
   {
        return 1;
   }
   else if(n < 0)
     return 1;
   else
   {
          if(d[n]> 0return d[n];
          d[n] = fibonacci(n-1+ fibonacci(n-2);
          return d[n];
   }
}
int main()
{
    int n;
    int T;
    int one;
    int zero;
    scanf("%d",&T);
    for(int i =0; i<T; i++)
    {
        scanf("%d",&n);
        one = fibonacci(n);
        zero = fibonacci(n-1);
        
        printf("%d %d\n",zero,one);
    }
}
 
 
cs


반응형

'PS > 백준' 카테고리의 다른 글

1149번 RGB거리  (0) 2018.12.05
7490번 0 만들기  (0) 2018.12.05
1065번 한수  (0) 2018.11.16
1110번 더하기 사이클  (0) 2018.11.14
2448번 별 찍기 - 11  (0) 2018.11.12

문제 링크 : https://www.acmicpc.net/problem/14891


해결방법)

문제를 읽고나서 생각해 봣는데 각 명령마다 순차적으로 톱뉘를 돌려나가면 되겠다라고 생각했다.

즉, 단순구현으로 풀었고(소스가 더러운느낌,..) 톱니번호와 회전방향을 가지고 있는 그대로 코드를 짜보았다.


- 알고리즘 순서 

1. 톱니 바퀴 정보를 입력받는다.

2. 각 명령을 하기 직전에 톱니들 사이의 접합부분이 맞닿았는지 혹은 떨어졌는지를 확인한다

3. 명령마다 주어진 바퀴번호와 회전방향을 보면서 해당 바퀴번호 기준으로 접합정보를 차례대로 비교해 나가면서 바퀴를 회전 시켜준다.

4. 명령이 끝날때까지 2,3번을 반복하고 반복이 끝나면 답을 구해줄 수 있다.



소스코드) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
#include<iostream>
#include<cstring>
#define LEFT 6
#define RIGHT 2
using namespace std;
int cnt_cmd;
int wheel[4][8]; // 바퀴 0, 1, 2, 3
// 0 1 2 3 4 로 0은 12시방향 
int flag[4]; // 4바퀴의 회전여부 
void Check(int wheel[][8])
{
    if (wheel[0][RIGHT] == wheel[1][LEFT])
    {
        flag[0= -1;
    }
    else
    {
        flag[0= 1;
    }
    if (wheel[1][RIGHT] == wheel[2][LEFT])
    {
        flag[1= -1;
    }
    else
    {
        flag[1= 1;
    }
    if (wheel[2][RIGHT] == wheel[3][LEFT])
    {
        flag[2= -1;
    }
    else
        flag[2= 1;
 
}
void moveLeft(int wheel[][8] , int wheelnum)
{
    int tmp = wheel[wheelnum][RIGHT];
    for (int i = 3; i <= 7; i++)
    {
        wheel[wheelnum][i - 1= wheel[wheelnum][i];
    }
    wheel[wheelnum][7= wheel[wheelnum][0];
    wheel[wheelnum][0= wheel[wheelnum][1];
    wheel[wheelnum][1= tmp;
}
void moveRight(int wheel[][8] , int wheelnum)
{
    int tmp = wheel[wheelnum][LEFT];
    for (int i = 5; i >= 0; i--)
    {
        wheel[wheelnum][i + 1= wheel[wheelnum][i];
    }
    wheel[wheelnum][0= wheel[wheelnum][7];
    wheel[wheelnum][7= tmp;
}
int main()
{
    for (int j = 0; j < 8; j++)
    {
        scanf("%1d"&wheel[0][j]);
    }
    for (int j = 0; j < 8; j++)
    {
        scanf("%1d"&wheel[1][j]);
    }
    for (int j = 0; j < 8; j++)
    {
        scanf("%1d"&wheel[2][j]);
    }
    for (int j = 0; j < 8; j++)
    {
        scanf("%1d"&wheel[3][j]);
    }
    /*for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 8; j++)
        {
            printf("%d ", wheel[i][j]);
        }
        puts("");
    }*/
    cin >> cnt_cmd;
    int select, dir;
    int ret = 0;
    int tmp;
    for (int i = 0; i < cnt_cmd; i++)
    {
        scanf("%d %d"&select, &dir);
        memset(flag, 0sizeof(flag));
        // 한번의 명령 마다 12시 방향값들을 더해나간다.
 
        Check(wheel);
        if (select == 1)
        {
            // 1번 바퀴일때 
            if (dir == -1)
            {
                moveLeft(wheel, 0);
                if (flag[0== 1// 다르다면 회전한다.
                {
                    //반시계일때
                    moveRight(wheel, 1);
                    if (flag[1== 1)
                    {
                        moveLeft(wheel, 2);
                        if (flag[2== 1)
                        {
                            moveRight(wheel, 3);
                        }
                    }
                }
            }
            else if (dir == 1)
            {
                //시계일때
                moveRight(wheel, 0);
                if (flag[0== 1// 다르다면 회전한다.
                {
                    moveLeft(wheel, 1);
                    if (flag[1== 1)
                    {
                        moveRight(wheel, 2);
                        if (flag[2== 1)
                        {
                            moveLeft(wheel, 3);
                        }
                    }
                }
            }
        }
        else if (select == 2)
        {
            if (dir == -1)
            {
                moveLeft(wheel, 1); // 두번째바퀴 시계반대돌리고
                if (flag[0== 1)
                {
                    moveRight(wheel, 0); // 첫번째바퀴 시계방향돌린다.
                }
                if (flag[1== 1)
                {
                    moveRight(wheel, 2);
                    if (flag[2== 1)
                    {
                        moveLeft(wheel, 3);
                    }
                }
            }
            else if (dir == 1)
            {
                moveRight(wheel, 1);
                if (flag[0== 1)
                {
                    moveLeft(wheel, 0);
                }
                if (flag[1== 1)
                {
                    moveLeft(wheel, 2);
                    if (flag[2== 1)
                    {
                        moveRight(wheel, 3);
                    }
                }
            }
        }
 
 
        else if (select == 3)
        {
            if (dir == -1)
            {
                moveLeft(wheel, 2);
                if (flag[1== 1)
                {
                    //왼쪽이 달라서 돌릴수잇다면 
                    moveRight(wheel, 1);
                    if (flag[0== 1)
                    {
                        moveLeft(wheel, 0);
                    }
                }
                if (flag[2== 1)
                {
                    moveRight(wheel, 3);
                }
            }
            else if (dir == 1)
            {
                moveRight(wheel, 2);
                if (flag[1== 1)
                {
                    moveLeft(wheel, 1);
                    if (flag[0== 1)
                    {
                        moveRight(wheel, 0);
                    }
                }
                if (flag[2== 1)
                {
                    moveLeft(wheel, 3);
                }
            }
        }
        else if (select == 4)
        {
            if (dir == -1)
            {
                moveLeft(wheel, 3);
                if (flag[2== 1)
                {
                    moveRight(wheel, 2);
                    if (flag[1== 1)
                    {
                        moveLeft(wheel, 1);
                        if (flag[0== 1)
                        {
                            moveRight(wheel, 0);
                        }
                    }
                }
            }
            else if (dir == 1)
            {
                moveRight(wheel, 3);
                if (flag[2== 1)
                {
                    moveLeft(wheel, 2);
                    if (flag[1== 1)
                    {
                        moveRight(wheel, 1);
                        if (flag[0== 1)
                        {
                            moveLeft(wheel, 0);
                        }
                    }
                }
            }
        }
 
    }
    ret = 0;
    if (wheel[0][0== 1)ret += 1;
    if (wheel[1][0== 1)ret += 2;
    if (wheel[2][0== 1)ret += 4;
    if (wheel[3][0== 1)ret += 8;
 
    cout << ret << '\n';
}
cs


반응형

'PS > 백준' 카테고리의 다른 글

2448번 별 찍기 - 11  (0) 2018.11.12
1966번 프린터 큐  (0) 2018.10.28
7576번 토마토  (0) 2018.10.24
2839 설탕배달  (0) 2018.10.19
15686번 치킨 배달  (0) 2018.10.14

+ Recent posts