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

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

 

17070번: 파이프 옮기기 1

유현이가 새 집으로 이사했다. 새 집의 크기는 N×N의 격자판으로 나타낼 수 있고, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 (r, c)로 나타낼 수 있다. 여기서 r은 행의 번호, c는 열의

www.acmicpc.net

그래프와 dp 연계 문제입니다.

 

파이프가 가로로 놓여있을 때, 세로로 놓여있을 때, 대각선으로 놓여있을 때 이동방법과 벽 위치 여부를 고려하여 dfs로 파이프를 움직여주고, 파이프의 한쪽 끝이 N, N에 도달하는 경우의 수를 dp를 이용하여 구해주시면 되겠습니다.

 

dfs만 쓰게 되면 파이프가 같은 위치로 여러번 탐색하게 되며 시간초과가 발생하게 됩니다.

따라서 dp를 사용하여 파이프가 방문한 위치에서는 해당위치의 경우의 수를 리턴해주면 됩니다.

 

 

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
#include <iostream>
#include <cstring>
using namespace std;
 
int list[17][17], dp[17][17][17][17];
int N, ans;
 
int dfs(int fx, int fy, int sx, int sy) {
    if (sx > N || sy > N) return 0;
    if (sx == N && sy == N) return 1;
    if (dp[fx][fy][sx][sy] != -1) return dp[fx][fy][sx][sy];
    dp[fx][fy][sx][sy] = 0;
 
    if (fx == sx && fy + 1 == sy) { //가로
        if (!list[sx][sy + 1]) {
            dp[fx][fy][sx][sy] += dfs(sx, sy, sx, sy + 1);
 
            if (!list[sx + 1][sy + 1] && !list[sx + 1][sy]) {
                dp[fx][fy][sx][sy] += dfs(sx, sy, sx + 1, sy + 1);
            }
        }
    }
    else if (fy == sy && fx + 1 == sx) { //세로
        if (!list[sx + 1][sy]) {
            dp[fx][fy][sx][sy] += dfs(sx, sy, sx + 1, sy);
 
            if (!list[sx + 1][sy + 1] && !list[sx][sy + 1]) {
                dp[fx][fy][sx][sy] += dfs(sx, sy, sx + 1, sy + 1);
            }
        }
    }
    else { //대각
        if (!list[sx + 1][sy]) {
            dp[fx][fy][sx][sy] += dfs(sx, sy, sx + 1, sy);
        }
        if (!list[sx][sy + 1]) {
            dp[fx][fy][sx][sy] += dfs(sx, sy, sx, sy + 1);
        }
        if (!list[sx + 1][sy] && !list[sx][sy + 1] && !list[sx + 1][sy + 1]) {
            dp[fx][fy][sx][sy] += dfs(sx, sy, sx + 1, sy + 1);
        }
    }
 
    return dp[fx][fy][sx][sy];
}
 
void input() {
    memset(dp, -1, sizeof(dp));
    cin >> N;
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) {
            cin >> list[i][j];
        }
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    cout << dfs(1, 1, 1, 2) << '\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 14226 이모티콘  (0) 2021.01.22
boj 11053 가장 긴 증가하는 부분 수열  (0) 2021.01.22
boj 1463 1로 만들기  (0) 2021.01.22

 

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

 

9663번: N-Queen

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다. N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

 

백트래킹의 대표적인 문제입니다.

퀸은 가로, 세로, 대각선 방향으로 어디든 갈 수 있으므로 서로 공격하지 못하게 하려면 위와 같은 형태가 되어야합니다.

 

문제에서는 위와 같은 형태가 몇 개 나올 수 있는지 출력하는 문제입니다.

 

x을 1씩 올려가면서 dfs를 돌리고 x,y 위치에서 y방향, 대각선 방향의 위치에 다른 퀸이 놓여져 있는지 체크 후에 놓는 방식으로 하였습니다.

 

y방향을 열을 나타내고, 대각선 방향은 /, \방향이 있습니다.

우선 좌표가 이런식으로 되어있습니다.

 

y 좌표는 말 그대로 (x, y)에서 y좌표만 체크해주시면 되고

 

대각선좌표는 이런식입니다.

왼쪽은 /방향 (x + y)를 나타낸것이고, 오른쪽은 \방향 (x - y + 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
#include <iostream>
using namespace std;
 
bool col[16], Left[27], Right[27];
int N, ans;
 
void dfs(int x) {
    if (x == N) {
        ans++;
        return;
    }
 
    for (int y = 0; y < N; y++) {
        if (col[y]) continue;
        if (Left[x + y] || Right[x - y + N - 1]) continue;
            col[y] = true;
            Left[x + y] = true;
            Right[x - y + N - 1] = true;
            dfs(x + 1);
            Right[x - y + N - 1] = false;
            Left[x + y] = false;
            col[y] = false;
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    cin >> N;
    dfs(0);
    cout << ans << '\n';
 
    return 0;
}
 cs

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

boj 15650 N 과 M (2)  (0) 2021.01.26
boj 15649 N 과 M (1)  (0) 2021.01.26
boj 2580 스도쿠  (0) 2021.01.22
boj 1759 암호 만들기  (0) 2021.01.22
boj 1062 가르침  (0) 2021.01.22

 

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

 

11053번: 가장 긴 증가하는 부분 수열

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오. 예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이

www.acmicpc.net

 

간단한 lis문제입니다.

 

N이 1부터 1000까지 이므로 N^2으로 접근하였습니다.

 

i번째 수가 j번째 수보다 크고 dp[j]+1이 dp[i]보다 크면 dp[i]을 업데이트 합니다.

 

dp에는 i번째 수보다 작은 수의 갯수가 저장되어 있으므로 최댓값에 +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
#include <iostream>
#include <algorithm>
using namespace std;
 
int list[1001], dp[1001], N, ans;
 
void input() {
    cin >> N;
    for (int i = 1; i <= N; i++) {
        cin >> list[i];
    }
}
 
void func() {
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j < i; j++) {
            if (list[j] < list[i] && dp[i] < dp[j] + 1) {
                dp[i] = dp[j] + 1;
            }
        }
 
        ans = max(ans, dp[i]);
    }
 
    cout << ans + 1 << '\n';
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
 
    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 14226 이모티콘  (0) 2021.01.22
boj 17070 파이프 옮기기 1  (0) 2021.01.22
boj 1463 1로 만들기  (0) 2021.01.22

 

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

 

20127번: Y-수열

N개의 정수로 이루어진 수열 a1, ... , aN이 있다. 택희는 해당 수열이 증가수열 혹은 감소수열이 되게 만들고 싶다. 증가수열은 모든 i(1 ≤ i < N)에 대해서 ai ≤ ai+1을 만족하는 수열이고, 감소수열

www.acmicpc.net

 

맨 앞의 k개의 원소를 맨 뒤로 옮겨서 증가 또는 감소수열을 만들어야하는데 여기서 k의 최솟값을 출력해야합니다.

반례로 만들 수 없다면 -1을 출력합니다.

 

우선 맨 앞의 연속된 k개의 원소를 한 번만 움직이는거기 때문에 주어진 배열 list를 구간별로 나누면 2개의 구간이 나옵니다.

 

(편의를 위해 앞에서부터 구간1, 구간2로 하겠습니다.)

구간1의 맨 앞의 숫자가 구간2의 뒤로 가기때문에

 

증가수열을 만들 때는

구간1의 맨 앞의 숫자가 구간2의 맨 뒤의 숫자보다 크거나 같아야하고,

감소수열을 만들 때는

구간1의 맨 앞의 숫자가 구간2의 맨 뒤의 숫자보다 작거나 같아야합니다.

증가, 감소 수열을 만들 때 나온 각각의 k를 비교하여 작은 수를 출력하면 됩니다.

 

예외처리로 구간이 1개 나온다면 그냥 증가 또는 감소수열이 주어진 것이므로 0을 출력하면 되고,

2개보다 많이 나온다면 만들 수 없는 것이므로 -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
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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static Queue<ArrayList<Integer>> inq = new LinkedList<>();
    static Queue<ArrayList<Integer>> deq = new LinkedList<>();
    static int N, inans, deans;
    static int list[] = new int[1000001];
 
    static void func() {
        ArrayList<Integer> newlist = new ArrayList<>();
        newlist.add(list[0]);
        for (int i = 1; i < N; i++) {
            if (list[i] >= list[i - 1])
                newlist.add(list[i]);
            else {
                inq.add(newlist);
                newlist = new ArrayList<>();
                newlist.add(list[i]);
            }
        }
        inq.add(newlist);
        if (inq.size() > 2)
            inans = -1;
        else if (inq.size() == 1)
            inans = 0;
        else {
            int size = inq.peek().size();
            int l = inq.peek().get(0);
            inq.remove();
            int r = inq.peek().get(inq.peek().size() - 1);
 
            if (l >= r)
                inans = size;
            else
                inans = -1;
        }
 
        newlist = new ArrayList<>();
        newlist.add(list[0]);
        for (int i = 1; i < N; i++) {
            if (list[i] <= list[i - 1])
                newlist.add(list[i]);
            else {
                deq.add(newlist);
                newlist = new ArrayList<>();
                newlist.add(list[i]);
            }
        }
        deq.add(newlist);
 
        if (deq.size() > 2)
            deans = -1;
        else if (deq.size() == 1)
            deans = 0;
        else {
            int size = deq.peek().size();
            int l = deq.peek().get(0);
            deq.remove();
            int r = deq.peek().get(deq.peek().size() - 1);
 
            if (r >= l)
                deans = size;
            else
                deans = -1;
        }
    }
 
    static void solve() {
        if (inans == -1 && deans == -1)
            System.out.println(-1);
        else if (inans == -1)
            System.out.println(deans);
        else if (deans == -1)
            System.out.println(inans);
        else
            System.out.println(Math.min(inans, deans));
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            list[i] = Integer.parseInt(st.nextToken());
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        solve();
    }
}
cs

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

boj 16918 봄버맨  (0) 2021.02.17
boj 16935 배열 돌리기 3  (0) 2021.02.10
boj 1914 하노이 탑  (0) 2021.02.07
boj 11729 하노이 탑 이동 순서  (0) 2021.02.07
boj 1244 스위치 켜고 끄기  (0) 2021.02.01

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

 

1463번: 1로 만들기

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

www.acmicpc.net

 

시험삼아 포스팅하는 문제로, 간단한 dp 문제입니다.

 

정수 X에 적용되는 연산들을 적절히 사용해서 X를 1로 만드는데 연산을 사용하는 횟수의 최솟값을 출력하는 문제입니다.

 

1. X가 3으로 나누어 떨어지면, 3으로 나눈다. → X가 3으로 나누어 떨어지면 X/3보다 횟수 +1

2. X가 2로 나누어 떨어지면, 2로 나눈다. → X가 2로 나누어 떨어지면 X/2보다 횟수 +1

3. 1을 뺀다. → X-1보다 횟수 +1

 

1, 2, 3번의 최솟값을 찾으면 되겠습니다.

(X=1일 때 횟수가 0이므로 2부터 반복문을 돌려줍니다.)

 

(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>
#include <algorithm>
using namespace std;
 
int dp[1000001], N;
 
int ans() {
    for (int i = 2; i <= N; i++) {
        dp[i] = dp[i - 1] + 1;
 
        if (i % 3 == 0) {
            dp[i] = min(dp[i], dp[i / 3] + 1);
        }
        if (i % 2 == 0) {
            dp[i] = min(dp[i], dp[i / 2] + 1);
        }
    }
    
    return dp[N];
}
 
int main() {
    cin >> N;
    cout << ans() << '\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
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 dp[];
    static int N;
 
    static void func() {
        for (int i = 2; i <= N; i++) {
            dp[i] = dp[i - 1] + 1;
 
            if (i % 2 == 0)
                dp[i] = Math.min(dp[i], dp[i / 2] + 1);
            if (i % 3 == 0)
                dp[i] = Math.min(dp[i], dp[i / 3] + 1);
        }
        
        System.out.println(dp[N]);
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        dp = new int[N + 1];
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
    }
}
 cs

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

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
boj 17070 파이프 옮기기 1  (0) 2021.01.22
boj 11053 가장 긴 증가하는 부분 수열  (0) 2021.01.22

+ Recent posts

티스토리툴바