https://www.acmicpc.net/problem/16195

 

16195번: 1, 2, 3 더하기 9

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다. 단, 사용한 수의 개수는 m개 이하 이어야 한다.

www.acmicpc.net

1, 2, 3 더하기 9번째 문제입니다.

 

emoney96.tistory.com/14

 

boj 15992 1, 2, 3 더하기 7

https://www.acmicpc.net/problem/15992 15992번: 1, 2, 3 더하기 7 각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다. 단, 사용한 수의 개수는 m개 이..

emoney96.tistory.com

위의 7번째 문제와 유사한 문제입니다.

7번째 문제는 1, 2, 3을 M개 사용하여 N을 만드는 방법의 수를 구하는 문제이고,

이 문제는 1, 2, 3을 M개 이하로 사용하여 N을 만드는 방법의 수를 구하는 문제입니다.

즉 M개, M - 1개, M - 2개, ..., 1개 까지의 방법의 수를 모두 구하는 문제입니다.

 

그러면 dp[N][M]는 M개 이하의 수로 N을 만드는 방법의 수라고 할 수 있습니다.

7번째 문제와 똑같이 점화식은 dp[N - 1][M - 1] + dp[N - 2][M - 1] + dp[N - 3][M - 1] 이렇게 되고

 

M개 이하의 수로 N을 만들기 때문에 dp[N][N]을 구할 때는 dp[N - 2][N - 1]와 dp[N - 3][N - 1]의 값을 더하기때문에 값이 채워져 있어야합니다.

 

 

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
#include <iostream>
#define MOD 1000000009
using namespace std;
 
int dp[1001][1001];
 
void init() {
    dp[1][1] = 1;
    dp[2][1] = 1;
    dp[2][2] = 2;
    dp[3][1] = 1;
    dp[3][2] = 3;
    dp[3][3] = 4;
    for (int i = 1; i <= 3; i++) {
        for (int j = i + 1; j <= i + 2; j++) {
            dp[i][j] = dp[i][j - 1];
        }
    }
 
    for (int i = 4; i <= 1000; i++) {
        for (int j = 1; j <= i; j++) {
            dp[i][j] = ((dp[i - 1][j - 1] + dp[i - 2][j - 1]) % MOD + dp[i - 3][j - 1]) % MOD;
        }
 
        for (int j = i + 1; j <= i + 2; j++) {
            dp[i][j] = dp[i][j - 1];
        }
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    int tc, N, M;
    cin >> tc;
    while (tc--) {
        cin >> N >> M;
        cout << dp[N][M] << '\n';
    }
 
    return 0;
}
 cs

'algorithm > dp' 카테고리의 다른 글

boj 1103 게임  (0) 2021.01.22
boj 12852 1로 만들기 2  (0) 2021.01.22
boj 15993 1, 2, 3 더하기 8  (0) 2021.01.22
boj 15992 1, 2, 3 더하기 7  (0) 2021.01.22
boj 15991 1, 2, 3 더하기 6  (0) 2021.01.22

 

https://www.acmicpc.net/problem/15993

 

15993번: 1, 2, 3 더하기 8

첫째 줄에 테스트 케이스의 개수 T가 주어진다. 각 테스트 케이스는 한 줄로 이루어져 있고, 정수 n이 주어진다. n은 양수이며 100,000보다 작거나 같다.

www.acmicpc.net

1, 2, 3 더하기 8번째 문제입니다.

이 문제는 7번째 문제와 비슷한 유형이라고 볼 수 있습니다.

7번째 문제에서는 M개의 수를 사용하여 N을 만드는 방법인데 이를 홀수, 짝수로 나누면 되는 문제입니다.

 

dp[N][0] → N을 만드는 방법 중 홀수개를 사용하는 경우

dp[N][1] → N을 만드는 방법 중 짝수개를 사용하는 경우

 

7번째 문제에서 dp[N]는 dp[N - 1]에서 +1, dp[N - 2]에서 +2, dp[N - 3]에서 +3을 한 것이라고 했었습니다.

즉, 갯수가 1개가 늘어난다는 말은 홀수는 짝수가 되고, 짝수는 홀수가 된다는 말입니다.

 

따라서 홀수의 갯수는 N - 1, N - 2, N - 3번째의 수를 짝수개를 사용하여 나타내는 방법의 수를 더한 값이고,

짝수의 갯수는 N - 1, N - 2, N - 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
#include <iostream>
#define MOD 1000000009
using namespace std;
 
int dp[100001][2];
 
void init() {
    dp[1][0] = 1;
    dp[2][0] = 1;
    dp[2][1] = 1;
    dp[3][0] = 2;
    dp[3][1] = 2;
    for (int i = 4; i <= 100000; i++) {
        dp[i][0] = ((dp[i - 1][1] + dp[i - 2][1]) % MOD + dp[i - 3][1]) % MOD;
        dp[i][1] = ((dp[i - 1][0] + dp[i - 2][0]) % MOD + dp[i - 3][0]) % MOD;
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    int tc, N;
    cin >> tc;
    while (tc--) {
        cin >> N;
        cout << dp[N][0] << ' ' << dp[N][1] << '\n';
    }
 
    return 0;
}
cs

'algorithm > dp' 카테고리의 다른 글

boj 12852 1로 만들기 2  (0) 2021.01.22
boj 16195 1, 2, 3 더하기 9  (0) 2021.01.22
boj 15992 1, 2, 3 더하기 7  (0) 2021.01.22
boj 15991 1, 2, 3 더하기 6  (0) 2021.01.22
boj 15990 1, 2, 3 더하기 5  (0) 2021.01.22

 

https://www.acmicpc.net/problem/15992

 

15992번: 1, 2, 3 더하기 7

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다. 단, 사용한 수의 개수는 m개 이어야 한다.

www.acmicpc.net

1, 2, 3 더하기 7번째 문제입니다.

이 문제는 정수 N을 1, 2, 3으로 나타내는 방법에서 M개의 수를 사용한 방법의 수를 출력하는 문제입니다.

 

dp[N][M] = N을 M개의 수로 나타내는 방법의 수

 

지금까지 1, 2, 3 더하기 문제는 대부분 N - 1에서 +1, N - 2에서 +2, N - 3에서 +3을 한 방법의 수를 구하는 문제였습니다. 즉, 하나의 수를 더했다는 말이 됩니다.

 

그러므로 dp[N][M]는

dp[N - 1][M - 1] (N - 1을 M - 1개의 수로 나타내는 방법의 수)와

dp[N - 2][M - 1] (N - 2을 M - 1개의 수로 나타내는 방법의 수)와

dp[N - 3][M - 1] (N - 3을 M - 1개의 수로 나타내는 방법의 수)를

더해주는 방법의 수가 되겠습니다.

 

 

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
#include <iostream>
#define MOD 1000000009
using namespace std;
 
int dp[1001][1001];
 
void init() {
    dp[1][1] = 1;
    dp[2][1] = 1;
    dp[2][2] = 1;
    dp[3][1] = 1;
    dp[3][2] = 2;
    dp[3][3] = 1;
    for (int i = 4; i <= 1000; i++) {
        for (int j = 1; j <= i; j++) {
            dp[i][j] = ((dp[i - 1][j - 1] + dp[i - 2][j - 1]) % MOD + dp[i - 3][j - 1]) % MOD;
        }
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    int tc, N, M;
    cin >> tc;
    while (tc--) {
        cin >> N >> M;
        cout << dp[N][M] << '\n';
    }
 
    return 0;
}
cs

'algorithm > dp' 카테고리의 다른 글

boj 16195 1, 2, 3 더하기 9  (0) 2021.01.22
boj 15993 1, 2, 3 더하기 8  (0) 2021.01.22
boj 15991 1, 2, 3 더하기 6  (0) 2021.01.22
boj 15990 1, 2, 3 더하기 5  (0) 2021.01.22
boj 15989 1, 2, 3 더하기 4  (0) 2021.01.22

 

https://www.acmicpc.net/problem/15991

 

15991번: 1, 2, 3 더하기 6

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다.

www.acmicpc.net

정수 N을 만드는 방법의 수를 구하는 문제인데 이 문제는 식이 대칭을 이루어야 합니다.

예를들어 N = 4일 때 1+1+1+1, 1+2+1, 2+2 이런 식은 가능하지만

1+1+2, 2+1+1, 1+3, 3+1 이런 식은 대칭을 이루지 않아 안된다는 점입니다.

 

대칭이라는 점을 이용하여,

N - 2를 이루는 식의 양 옆에 1씩 더하는 경우,

N - 4를 이루는 식의 양 옆에 2씩 더하는 경우,

N - 6을 이루는 식의 양 옆에 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
#include <iostream>
#define MOD 1000000009
using namespace std;
 
int dp[100001];
 
void init() {
    dp[0] = 1;
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 2;
    dp[4] = 3;
    dp[5] = 3;
    for (int i = 6; i <= 100000; i++) {
        dp[i] = ((dp[i - 2] + dp[i - 4]) % MOD + dp[i - 6]) % MOD;
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    int tc, N;
    cin >> tc;
    while (tc--) {
        cin >> N;
        cout << dp[N] << '\n';
    }
 
    return 0;
}
cs

'algorithm > dp' 카테고리의 다른 글

boj 15993 1, 2, 3 더하기 8  (0) 2021.01.22
boj 15992 1, 2, 3 더하기 7  (0) 2021.01.22
boj 15990 1, 2, 3 더하기 5  (0) 2021.01.22
boj 15989 1, 2, 3 더하기 4  (0) 2021.01.22
boj 15988 1, 2, 3 더하기 3  (0) 2021.01.22

 

https://www.acmicpc.net/problem/15990

 

15990번: 1, 2, 3 더하기 5

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다.

www.acmicpc.net

1, 2, 3 더하기 4 문제를 푼 다음이어서 그런지 점화식을 빠르게 찾았습니다.

 

이 문제는 식이 1로 끝나는 경우, 2로 끝나는 경우, 3으로 끝나는 경우로 나누어 해결합니다.

1 → 1

2 → 2

3 → 2+1, 1+2, 3

 

이제 점화식을 세워보면,

dp[0][N] (N을 나타내는 방법 중 1로 끝나는 방법의 수)

= dp[1][N - 1] + dp[2][N - 1] (N - 1에서 2로 끝나는 방법 + 3으로 끝나는 방법)

 

dp[1][N] (N을 나타내는 방법 중 2로 끝나는 방법의 수)

= dp[0][N - 2] + dp[2][N - 2] (N - 2에서 1로 끝나는 방법 + 3으로 끝나는 방법)

 

dp[2][N] (N을 나타내는 방법 중 3로 끝나는 방법의 수)

= dp[0][N - 3] + dp[1][N - 3] (N - 3에서 1로 끝나는 방법 + 2로 끝나는 방법)

 

이렇게 되겠습니다.

 

 

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
#include <iostream>
#define MOD 1000000009
using namespace std;
 
int dp[3][100001];
 
void init() {
    dp[0][1] = 1;
    dp[1][2] = 1;
    dp[0][3] = 1;
    dp[1][3] = 1;
    dp[2][3] = 1;
    for (int i = 4; i <= 100000; i++) {
        dp[0][i] = (dp[1][i - 1] + dp[2][i - 1]) % MOD;
        dp[1][i] = (dp[0][i - 2] + dp[2][i - 2]) % MOD;
        dp[2][i] = (dp[0][i - 3] + dp[1][i - 3]) % MOD;
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    int tc, N;
    cin >> tc;
    while (tc--) {
        cin >> N;
        cout << ((dp[0][N] + dp[1][N]) % MOD + dp[2][N]) % MOD << '\n';
    }
 
    return 0;
}
cs

'algorithm > dp' 카테고리의 다른 글

boj 15992 1, 2, 3 더하기 7  (0) 2021.01.22
boj 15991 1, 2, 3 더하기 6  (0) 2021.01.22
boj 15989 1, 2, 3 더하기 4  (0) 2021.01.22
boj 15988 1, 2, 3 더하기 3  (0) 2021.01.22
boj 12101 1, 2, 3 더하기 2  (0) 2021.01.22

https://www.acmicpc.net/problem/15989

 

15989번: 1, 2, 3 더하기 4

정수 4를 1, 2, 3의 합으로 나타내는 방법은 총 4가지가 있다. 합을 나타낼 때는 수를 1개 이상 사용해야 한다. 합을 이루고 있는 수의 순서만 다른 것은 같은 것으로 친다. 1+1+1+1 2+1+1 (1+1+2, 1+2+1) 2+2

www.acmicpc.net

 

제 개인적으로는 생각을 좀 해봐야했던 dp문제였습니다 ㅠㅠ.. 오래안해서 다죽은듯..

 

처음에는 방법의 수를 하나하나 나열해봤지만 해답을 찾을수 없었는데..

 

1, 2, 3으로 나타내는 방법의 수를 나누는 방법을 생각해보았습니다.

1. 1이하의 수로 나타내는 방법

2. 2이하의 수로 나타내는 방법

3. 3이하의 수로 나타내는 방법

으로 나눌 수 있습니다.

 

1이하로 나타내는 방법은 i - 1번째의 1이하로 나타내는 방법과 같습니다.

2이하로 나타내는 방법은 i - 2번째의 1이하로 나타내는 방법 + 2이하로 나타내는 방법입니다.

3이하로 나타내는 방법은 i - 3번째의 1이하로 나타내는 방법 + 2이하로 나타내는 방법 + 3이하로 나타내는 방법입니다.

 

따라서 dp[0][N], dp[1][N], dp[2][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
#include <iostream>
using namespace std;
 
int dp[3][10001];
 
void init() {
    dp[0][1] = 1;
    dp[0][2] = 1;
    dp[1][2] = 1;
    dp[0][3] = 1;
    dp[1][3] = 1;
    dp[2][3] = 1;
    for (int i = 4; i <= 10000; i++) {
        dp[0][i] = dp[0][i - 1];
        dp[1][i] = dp[0][i - 2] + dp[1][i - 2];
        dp[2][i] = dp[0][i - 3] + dp[1][i - 3] + dp[2][i - 3];
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    int tc, N;
    cin >> tc;
    while (tc--) {
        cin >> N;
        cout << dp[0][N] + dp[1][N] + dp[2][N] << '\n';
    }
 
    return 0;
}
 cs

'algorithm > dp' 카테고리의 다른 글

boj 15991 1, 2, 3 더하기 6  (0) 2021.01.22
boj 15990 1, 2, 3 더하기 5  (0) 2021.01.22
boj 15988 1, 2, 3 더하기 3  (0) 2021.01.22
boj 12101 1, 2, 3 더하기 2  (0) 2021.01.22
boj 9095 1, 2, 3 더하기  (0) 2021.01.22

 

https://www.acmicpc.net/problem/15988

 

15988번: 1, 2, 3 더하기 3

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 1,000,000,009로 나눈 나머지를 출력한다.

www.acmicpc.net

9095번 문제와 같은문제지만 N이 1000000까지이고, dp[N] % 1000000009를 출력하는 문제입니다.

 

https://emoney96.tistory.com/8

 

boj 9095 1, 2, 3 더하기

https://www.acmicpc.net/problem/9095 9095번: 1, 2, 3 더하기 각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다. www.acmicpc.net 정수를 1, 2, 3의 합으로만 나타내는 방법의 수를..

emoney96.tistory.com

위의 풀이처럼 dp[i]값을 채워나가는 과정에서 int의 범위를 넘어서기 때문에 중간에 1000000009로 나눠주면서 더해야합니다.

 

 

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
#include <iostream>
#define MOD 1000000009
using namespace std;
 
int dp[1000001];
 
void func() {
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 4;
    for (int i = 4; i <= 1000000; i++) {
        dp[i] = ((dp[i - 1] + dp[i - 2]) % MOD + dp[i - 3]) % MOD;
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    func();
    int tc, x;
    cin >> tc;
    while (tc--) {
        cin >> x;
        cout << dp[x] << '\n';
    }
 
    return 0;
}
 cs

'algorithm > dp' 카테고리의 다른 글

boj 15990 1, 2, 3 더하기 5  (0) 2021.01.22
boj 15989 1, 2, 3 더하기 4  (0) 2021.01.22
boj 12101 1, 2, 3 더하기 2  (0) 2021.01.22
boj 9095 1, 2, 3 더하기  (0) 2021.01.22
boj 14226 이모티콘  (0) 2021.01.22

https://www.acmicpc.net/problem/9095

 

9095번: 1, 2, 3 더하기

각 테스트 케이스마다, n을 1, 2, 3의 합으로 나타내는 방법의 수를 출력한다.

www.acmicpc.net

정수를 1, 2, 3의 합으로만 나타내는 방법의 수를 출력하는 dp문제입니다.

1 → 1 (1개)

2 → 1+1, 2 (2개)

3 → 1+1+1, 1+2, 2+1, 3 (4개)

 

4 → 1+1+1+1, 1+1+2, 1+2+1, 1+3 / 2+1+1, 2+2 / 3+1 (7개)

 

여기서 4는

3을 나타내는 방법에 1을 더한것과

2를 나타내는 방법에 2를 더한것과

1을 나타내는 방법에 3을 더한것을

모두 더한 값이 되는것을 알 수 있습니다.

 

이것으로 점화식을 나타내면 dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]이 됩니다.

 

(+Java 소스 추가하였습니다.)

 

[C++]

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
#include <iostream>
using namespace std;
 
int N, dp[11];
 
void init() {
    dp[1] = 1;
    dp[2] = 2;
    dp[3] = 4;
 
    for (int i = 4; i <= 10; i++) {
        dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
    }
}
 
int main() {
    init();
 
    int Testcase;
    cin >> Testcase;
    while (Testcase--) {
        cin >> N;
        cout << dp[N] << '\n';
    }
 
    return 0;
}
 cs

 

[Java]

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static StringBuffer sb = new StringBuffer();
    static int dp[] = new int[11];
    static int N;
 
    static void init() {
        dp[1] = 1;
        dp[2] = 2;
        dp[3] = 4;
        for (int i = 4; i <= 10; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
        }
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
    }
 
    public static void main(String[] args) throws Exception {
        init();
        st = new StringTokenizer(br.readLine());
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            input();
            sb.append(dp[N] + "\n");
        }
 
        System.out.println(sb.toString());
    }
}
 cs

'algorithm > dp' 카테고리의 다른 글

boj 15988 1, 2, 3 더하기 3  (0) 2021.01.22
boj 12101 1, 2, 3 더하기 2  (0) 2021.01.22
boj 14226 이모티콘  (0) 2021.01.22
boj 17070 파이프 옮기기 1  (0) 2021.01.22
boj 11053 가장 긴 증가하는 부분 수열  (0) 2021.01.22

+ Recent posts

티스토리툴바