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

 

1806번: 부분합

첫째 줄에 N (10 ≤ N < 100,000)과 S (0 < S ≤ 100,000,000)가 주어진다. 둘째 줄에는 수열이 주어진다. 수열의 각 원소는 공백으로 구분되어져 있으며, 10,000이하의 자연수이다.

www.acmicpc.net

연속된 수들의 부분합이기 때문에 two pointer로 해결할 수 있습니다.

저는 two pointer와 dp를 사용하였습니다.

 

우선 dp에 연속합을 저장해놓고

l~r의 합이 S보다 작으면 r++

l~r의 합이 S보다 크거나 같으면 ans을 갱신하고 l++

이 과정을 반복하여 ans을 출력하였습니다.

 

예외처리로 모든 값을 더해도 S보다 작다면 0을 출력합니다.

 

 

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
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 int list[], dp[];
    static int N, S, ans = 100000;
 
    static void func() {
        int l = 1;
        int r = 1;
 
        while (r <= N) {
            if (dp[r] - dp[l - 1] < S) {
                r++;
            } else {
                ans = Math.min(ans, r - l + 1);
                l++;
            }
        }
 
        if (ans == 100000)
            ans = 0;
        System.out.println(ans);
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        S = Integer.parseInt(st.nextToken());
        list = new int[N + 1];
        dp = new int[N + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
            dp[i] = dp[i - 1] + list[i];
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

'algorithm > Two-Pointer' 카테고리의 다른 글

boj 1253 좋다  (0) 2021.10.21
boj 9024 두 수의 합  (0) 2021.10.21
boj 17609 회문  (0) 2021.03.29
boj 2559 수열  (0) 2021.02.12
boj 2003 수들의 합 2  (0) 2021.01.22

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

 

2003번: 수들의 합 2

첫째 줄에 N(1 ≤ N ≤ 10,000), M(1 ≤ M ≤ 300,000,000)이 주어진다. 다음 줄에는 A[1], A[2], …, A[N]이 공백으로 분리되어 주어진다. 각각의 A[x]는 30,000을 넘지 않는 자연수이다.

www.acmicpc.net

dp로 list의 연속 합을 구현하였고 two pointer로 인덱스를 조정해가며 M과 비교하였습니다.

l~r의 합이 M과 같으면 정답인 경우이므로 ans++

l~r의 합이 M보다 작으면 수를 더해야하므로 r++

l~r의 합이 M보다 크면 수를 빼야하므로 l++

이 과정을 반복하여 r이 list.length와 같아지면 중지하면 됩니다.

 

 

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
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 int list[], dp[];
    static int N, M, ans;
 
    static void func() {
        int l = 1;
        int r = 1;
        while (r < list.length) {
            if (dp[r] - dp[l - 1] == M) {
                ans++;
                l++;
            } else if (dp[r] - dp[l - 1] > M) {
                l++;
            } else
                r++;
        }
 
        System.out.println(ans);
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
 
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        list = new int[N + 1];
        dp = new int[N + 1];
 
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
            dp[i] = dp[i - 1] + list[i];
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
cs

'algorithm > Two-Pointer' 카테고리의 다른 글

boj 1253 좋다  (0) 2021.10.21
boj 9024 두 수의 합  (0) 2021.10.21
boj 17609 회문  (0) 2021.03.29
boj 2559 수열  (0) 2021.02.12
boj 1806 부분합  (0) 2021.01.22

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

 

1103번: 게임

줄에 보드의 세로 크기 N과 가로 크기 M이 주어진다. 이 값은 모두 50보다 작거나 같은 자연수이다. 둘째 줄부터 N개의 줄에 보드의 상태가 주어진다. 쓰여 있는 숫자는 1부터 9까지의 자연수 또는

www.acmicpc.net

그냥 dfs돌리다가 시간초과난 적이 있어서 dp를 같이 사용하였습니다.

 

보드에 적혀있는 숫자에 맞춰서 동전을 움직여서 최대 몇 번 움직일 수 있는지 구하는 문제입니다.

중간에 있는 구멍은 무시해도 되고, 도착지점이 구멍인 경우에는 동전이 빠지므로 이동하지 못합니다.

dfs로 모든 경우를 다 돌아보고 횟수를 구하면 됩니다.

예외처리로 무한루프가 있는 경우 -1을 출력해야하는데, dfs를 돌다가 방문처리된 곳에 다시 한 번 가게 되면 무한루프 판정으로 -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
57
58
59
60
61
62
63
64
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static char list[][] = new char[50][50];
    static boolean visit[][] = new boolean[50][50];
    static int dp[][] = new int[50][50];
    static int direct[][] = { { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 0 } };
    static int N, M, ans;
 
    static int dfs(int x, int y) {
        if (visit[x][y])
            return ans = -1;
        visit[x][y] = true;
        if (dp[x][y] != -1)
            return dp[x][y];
 
        dp[x][y] = 0;
        for (int i = 0; i < 4; i++) {
            int nx = x + direct[i][0] * (list[x][y] - '0');
            int ny = y + direct[i][1] * (list[x][y] - '0');
 
            if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                continue;
            if (list[nx][ny] == 'H')
                continue;
 
            dp[x][y] = Math.max(dp[x][y], dfs(nx, ny) + 1);
            if (ans == -1)
                return ans;
            visit[nx][ny] = false;
        }
 
        return dp[x][y];
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
 
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
 
            list[i] = st.nextToken().toCharArray();
        }
 
        for (int i = 0; i < N; i++) {
            Arrays.fill(dp[i], -1);
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        ans = dfs(0, 0);
        if (ans != -1)
            ans++;
        System.out.println(ans);
    }
}
 cs

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

boj 9657 돌 게임 3  (0) 2021.01.27
boj 2096 내려가기  (0) 2021.01.22
boj 12852 1로 만들기 2  (0) 2021.01.22
boj 16195 1, 2, 3 더하기 9  (0) 2021.01.22
boj 15993 1, 2, 3 더하기 8  (0) 2021.01.22

 

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

+ Recent posts

티스토리툴바