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

 

12852번: 1로 만들기 2

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 자연수 N이 주어진다.

www.acmicpc.net

emoney96.tistory.com/2

 

boj 1463 1로 만들기

https://www.acmicpc.net/problem/1463 1463번: 1로 만들기 첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다. www.acmicpc.net 시험삼아 포스팅하는 문제로, 간단한 dp 문제입니다. 정수 X에..

emoney96.tistory.com

이 문제에 경로가 추가된 문제입니다. 경로 출력을 위해 parent배열을 사용합니다.

 

먼저, dp[i - 1] + 1을 하면서 parent[i]에 i - 1을 저장합니다.

그다음, i가 3의 배수이고 dp[i] > dp[i / 3]이면 dp[i]를 갱신하고 parent[i]도 i / 3으로 갱신합니다.

마지막으로, i가 2의 배수이고 dp[i] > dp[i / 2]이면 dp[i]를 갱신하고 parent[i]도 i/2로 갱신합니다.

 

이제 dp[N]을 출력하고, N부터 parent배열의 값들을 참조하며 출력합니다.

 

 

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
#include <iostream>
using namespace std;
 
int dp[1000001], parent[1000001];
 
void func(int N) {
    for (int i = 2; i <= N; i++) {
        dp[i] = dp[i - 1] + 1;
        parent[i] = i - 1;
 
        if (i % 3 == 0) {
            if (dp[i] > dp[i / 3]) {
                parent[i] = i / 3;
                dp[i] = dp[i / 3] + 1;
            }
        }
        
        if (i % 2 == 0) {
            if (dp[i] > dp[i / 2]) {
                parent[i] = i / 2;
                dp[i] = dp[i / 2] + 1;
            }
        }
    }
}
 
void print(int v) {
    cout << dp[v] << '\n';
    for (int i = v; i != 0; i = parent[i]) {
        cout << i << ' ';
    }
    cout << '\n';
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    int N;
    cin >> N;
    func(N);
    print(N);
 
    return 0;
}
cs

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

boj 2096 내려가기  (0) 2021.01.22
boj 1103 게임  (0) 2021.01.22
boj 16195 1, 2, 3 더하기 9  (0) 2021.01.22
boj 15993 1, 2, 3 더하기 8  (0) 2021.01.22
boj 15992 1, 2, 3 더하기 7  (0) 2021.01.22

 

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

 

17124번: 두 개의 배열

정수 배열 A 와 B가 있다. A는 총 n개의 서로 다른 양의 정수를 포함하고 B는 총 m개의 서로 다른 양의 정수를 포함한다. A, B를 이용해서 길이가 n인 새로운 배열 C를 만들어보자. C[i] 는 배열 B에 있

www.acmicpc.net

C[i]는 배열 B에 있는 값 중에 A[i]에 가장 가까운 값이고 가장 가까운 값이 2개면 더 작은값입니다.

배열의 크기가 100만이므로 선형으로 찾기에는 무조건 시간초과이므로 이분탐색을 사용합니다.

(이분탐색을 위해 B 배열을 정렬해줍니다.)

 

A[i]가 주어지면

B 배열에서 A[i]보다 작은 값중에 가장 큰 값 = l

B 배열에서 A[i]보다 큰 값중에 가장 작은 값 = r

이러면 l과 r 둘중에 하나는 정답입니다.

 

abs(A[i] - l) vs abs(A[i] - r)를 비교하여 차이가 적은 값 (차이가 같으면 둘 중에 작은 값) 을 ans에 더해줍니다.

배열에 10^9까지 올 수 있으므로 long long 타입으로 계산하였습니다.

 

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
#include <iostream>
#include <algorithm>
#define INF 1000000000
using namespace std;
typedef long long ll;
 
int A[1000001], B[1000001];
int N, M;
ll ans;
 
int largesearch(int l, int r, int x) {
    int m = (l + r) / 2;
 
    if (B[m] == x) return B[m];
    else if (B[m] > x) {
        if (l == m) return B[m];
        else return min(B[m], largesearch(l, m - 1, x));
    }
    else {
        if (m == r) return INF;
        else return largesearch(m + 1, r, x);
    }
}
 
int smallsearch(int l, int r, int x) {
    int m = (l + r) / 2;
 
    if (B[m] == x) return B[m];
    else if (B[m] < x) {
        if (m == r) return B[m];
        else return max(B[m], smallsearch(m + 1, r, x));
    }
    else {
        if (l == m) return -1;
        else return smallsearch(l, m - 1, x);
    }
}
 
void func() {
    int l = 0, r = 0;
    for (int i = 1; i <= N; i++) {
        l = smallsearch(1, M, A[i]);
        r = largesearch(1, M, A[i]);
        if (l == -1) l = B[1];
        if (r == -1) r = B[M];
 
        if (abs(A[i] - l) <= abs(r - A[i])) {
            ans += l;
        }
        else ans += r;
    }
    cout << ans << '\n';
}
 
void input() {
    cin >> N >> M;
    for (int i = 1; i <= N; i++) {
        cin >> A[i];
    }
 
    for (int i = 1; i <= M; i++) {
        cin >> B[i];
    }
    sort(B + 1, B + 1 + M);
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    int tc;
    cin >> tc;
    while (tc--) {
        input();
        func();
        ans = 0;
    }
 
    return 0;
}
 cs

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

boj 2110 공유기 설치  (0) 2021.04.13
boj 7453 합이 0인 네 정수  (0) 2021.01.22
boj 2143 두 배열의 합  (0) 2021.01.22
boj 2805 나무 자르기  (0) 2021.01.22
boj 1920 수 찾기  (0) 2021.01.22

 

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/12101

 

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

n을 1, 2, 3의 합으로 나타내는 방법 중에서 사전 순으로 k번째에 오는 것을 출력한다. k번째 오는 식이 없는 경우에는 -1을 출력한다.

www.acmicpc.net

정수 N을 1, 2, 3의 합으로 나타내는 방법의 수를 사전순으로 정렬하여 k번째로 오는 식을 구하는 문제입니다.

 

먼저, N을 나타내는 방법의 수보다 k가 더 클수가 있기 때문에 dp배열에 N을 나타내는 방법의 수를 미리 저장하여 dp[N] < k이면 -1을 출력합니다.

 

다음은 문제 풀이 방법입니다.

예를들어, 4를 나타내는 방법은

1. 1+1+1+1

2. 1+1+2

3. 1+2+1

4. 1+3

5. 2+1+1

6. 2+2

7. 3+1

이렇게 7가지가 있는데, 여기서 1~4번은 3에서 1은 더한 것, 5~6번은 2에서 2를 더한 것, 7번은 1에서 3을 더한 것임을 알 수 있습니다. 이제 dp[N - 1]와 k를 비교합니다.

 

k가 5라고 하면, dp[4] = 7 > k = 5이므로 k번째 식이 있습니다.

그러면 dp[3]과 k를 비교합니다.

(n = 4)(dp[3] = 4) < (k = 5) 즉, 3에서 1을 더한 식이 아니므로 dp[2]과 k - dp[3]을 비교합니다. (n은 그대로 유지)

(n = 4)(dp[2] = 2) > (k = 1) 즉, 2에서 2를 더한 식이므로 식에 "2+"를 추가하고 그 다음 순서를 확인하기 위해 dp[1]과 k를 비교합니다. (n은 idx값인 2로 바뀜)

(n = 2)(dp[1] = 1) = (k = 1) 즉, 1에서 1을 더한 식이므로 식에 "1+"를 추가하고 그 다음 순서를 확인합니다.

(n = 1) n이 1이므로 식에 '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
45
46
47
48
49
50
51
52
53
54
55
56
#include <iostream>
#include <string>
using namespace std;
 
int dp[11], N, K;
 
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];
    }
}
 
void func(int idx, int n, int k, string str) {
    if (n == 1) {
        str += '1';
        cout << str << '\n';
        return;
    }
    else if (n == 2 && k == 2) {
        str += '2';
        cout << str << '\n';
        return;
    }
    else if (n == 3 && k == 4) {
        str += '3';
        cout << str << '\n';
        return;
    }
 
    if (k > dp[idx]) {
        func(idx - 1, n, k - dp[idx], str);
    }
    else {
        str += (n - idx + '0');
        str += '+';
        func(idx - 1, idx, k, str);
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    init();
    cin >> N >> K;
    if (dp[N] < K) {
        cout << "-1\n";
        return 0;
    }
    func(N - 1, N, K, "");
 
    return 0;
}
cs

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

boj 15989 1, 2, 3 더하기 4  (0) 2021.01.22
boj 15988 1, 2, 3 더하기 3  (0) 2021.01.22
boj 9095 1, 2, 3 더하기  (0) 2021.01.22
boj 14226 이모티콘  (0) 2021.01.22
boj 17070 파이프 옮기기 1  (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

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

 

14226번: 이모티콘

영선이는 매우 기쁘기 때문에, 효빈이에게 스마일 이모티콘을 S개 보내려고 한다. 영선이는 이미 화면에 이모티콘 1개를 입력했다. 이제, 다음과 같은 3가지 연산만 사용해서 이모티콘을 S개 만

www.acmicpc.net

우선 입력되어있는 이모티콘 1개를 복사해서 계속 붙여나가는 시간을 계산하였습니다.

(dp[1]=0이지만 입력에 1이 주어지지 않기때문에 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
#include <iostream>
#include <algorithm>
using namespace std;
 
int dp[2001], clip;
 
int func(int N) {
    dp[1] = 1;
    for (int i = 1; i <= 2000; i ++) {
        dp[i + 1] = dp[i] + 1;
    }
    
    clip = 2;
    while (clip <= 1001) {
        int r = dp[clip] + 2;
        dp[clip * 2] = min(dp[clip * 2], dp[clip] + 2);
        for (int i = clip * 3; i + clip <= 2000; i += clip) {
            dp[i] = min(dp[i], r + 1);
            r++;
        }
 
        for (int i = clip * 2 - 1; i >= clip + 1; i--) {
            dp[i] = min(dp[i], dp[i + 1] + 1);
        }
        clip++;
    }
 
    return dp[N];
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    int N;
    cin >> N;
    cout << func(N) << '\n';
 
    return 0;
}
cs

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

boj 12101 1, 2, 3 더하기 2  (0) 2021.01.22
boj 9095 1, 2, 3 더하기  (0) 2021.01.22
boj 17070 파이프 옮기기 1  (0) 2021.01.22
boj 11053 가장 긴 증가하는 부분 수열  (0) 2021.01.22
boj 1463 1로 만들기  (0) 2021.01.22

+ Recent posts

티스토리툴바