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

 

3425번: 고스택

각각의 입력값에 대해서, 해당하는 프로그램을 수행한 뒤, 출력값을 출력하면 된다. 출력값이란 스택에 저장되어 있는 숫자이다. 만약, 프로그램 에러가 발생하거나, 모든 수행이 종료됐을 때

www.acmicpc.net

[이 문제에서 수행하는 연산]

NUM X : X를 스택의 가장 위에 저장

POP : 스택 가장 위의 숫자를 제거

INV : 첫 번째 수의 부호를 변경

DUP : 첫 번째 수를 스택의 가장위에 한번 더 저장

SWP : 첫 번째 수와 두 번째 수의 위치를 변경

ADD : 첫 번째 수 + 두 번째 수

SUB : 두 번째 수 - 첫 번째 수

MUL : 첫 번째 수 * 두 번째 수

DIV : 두 번째 수 / 첫 번째 수

MOD : 두 번째 수 % 첫 번째 수

 

위의 연산들이 랜덤으로 주어지고, 입력값 V가 주어질 때마다 이 연산들을 수행한 결과를 출력합니다.

 

문제에서 요구하는 조건을 종합하면

1. 숫자가 부족해서 연산수행을 하지 못할 때

2. DIV, MOD 연산 시 0으로 나눴을 때

3. 연산 결과의 절댓값이 109 보다 클 때

4. 모든 연산이 종료되었을 때 스택에 저장되어 있는 숫자가 1개가 아닐 때

라고 할 수 있고, 그럼 출력값의 조건으로는

 

모든 연산이 종료되었을 때 스택에 저장되어 있는 숫자가 1개이고 절댓값이 109보다 작거나 같을 때 입니다.

 

나머지는 연산이 요구하는대로 계산해 주시면 됩니다.

 

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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Stack;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br;
    static StringTokenizer st;
    static String type;
    static ArrayList<String[]> list = new ArrayList<>();
    static Stack<long[]> stack = new Stack<>();
    static long N;
    static final long INF = 1000000000;
 
    static boolean func() {
        stack.push(new long[] {N});
        for (String[] arr : list) {
            if ("NUM".equals(arr[0])) {
                stack.push(new long[] {Long.parseLong(arr[1])});
            } else if ("POP".equals(arr[0])) {
                if (stack.isEmpty())
                    return false;
                stack.pop();
            } else if ("INV".equals(arr[0])) {
                if (stack.isEmpty())
                    return false;
                long a = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {-a});
            } else if ("DUP".equals(arr[0])) {
                if (stack.isEmpty())
                    return false;
                stack.push(stack.peek());
            } else if ("SWP".equals(arr[0])) {
                if (stack.size() < 2)
                    return false;
                long num1 = stack.peek()[0];
                stack.pop();
                long num2 = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {num1});
                stack.push(new long[] {num2});
            } else if ("ADD".equals(arr[0])) {
                if (stack.size() < 2)
                    return false;
                long num1 = stack.peek()[0];
                stack.pop();
                long num2 = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {num1+num2});
            } else if ("SUB".equals(arr[0])) {
                if (stack.size() < 2)
                    return false;
                long num1 = stack.peek()[0];
                stack.pop();
                long num2 = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {num2-num1});
            } else if ("MUL".equals(arr[0])) {
                if (stack.size() < 2)
                    return false;
                long num1 = stack.peek()[0];
                stack.pop();
                long num2 = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {num1*num2});
            } else if ("DIV".equals(arr[0])) {
                if (stack.size() < 2)
                    return false;
                long num1 = stack.peek()[0];
                stack.pop();
                if (num1 == 0)
                    return false;
                long num2 = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {num2/num1});
            } else if ("MOD".equals(arr[0])) {
                if (stack.size() < 2)
                    return false;
                long num1 = stack.peek()[0];
                stack.pop();
                if (num1 == 0)
                    return false;
                long num2 = stack.peek()[0];
                stack.pop();
                stack.push(new long[] {num2%num1});
            }
        }
        
        return true;
    }
 
    static void numinput() throws Exception {
        boolean chk = false;
        st = new StringTokenizer(br.readLine());
 
        int tc = Integer.parseInt(st.nextToken());
        while (tc-- > 0) {
            st = new StringTokenizer(br.readLine());
 
            N = Long.parseLong(st.nextToken());
            chk = func();
            if (!chk || stack.size() != 1) {
                System.out.println("ERROR");
            } else {
                if(Math.abs(stack.peek()[0])>INF)
                    System.out.println("ERROR");    
                else
                    System.out.println(stack.peek()[0]);
            }
 
            while (!stack.isEmpty())
                stack.pop();
        }
        
        while(!list.isEmpty())
            list.remove(0);
    }
 
    static void typeinput() throws Exception {
        while (true) {
            st = new StringTokenizer(br.readLine());
 
            type = st.nextToken();
            if ("NUM".equals(type)) {
                String num = st.nextToken();
                list.add(new String[] { type, num });
            } else if ("END".equals(type) || "QUIT".equals(type)) {
                break;
            } else {
                list.add(new String[] { type });
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        br = new BufferedReader(new InputStreamReader(System.in));
        while (true) {
            typeinput();
            if ("QUIT".equals(type))
                break;
            numinput();
            st = new StringTokenizer(br.readLine());
            System.out.println();
        }
    }
}
 
cs

'algorithm > data-structure' 카테고리의 다른 글

boj 4358 생태학  (0) 2021.01.25
boj 5639 이진 검색 트리  (0) 2021.01.24
boj 1991 트리 순회  (0) 2021.01.22
boj 11003 최솟값 찾기  (0) 2021.01.22
boj 2517 달리기  (0) 2021.01.22

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

 

2234번: 성곽

첫째 줄에 두 정수 n, m이 주어진다. 다음 m개의 줄에는 n개의 정수로 벽에 대한 정보가 주어진다. 벽에 대한 정보는 한 정수로 주어지는데, 서쪽에 벽이 있을 때는 1을, 북쪽에 벽이 있을 때는 2를,

www.acmicpc.net

저는 두 번의 bfs를 사용하였습니다.

한번은 각 방의 넘버링을 위한 bfs, 다른 한번은 각 방에 인접한 방을 찾기 위한 bfs입니다.

 

최종으로 구해야 할 것이

1. 이 성에 있는 방의 개수

2. 가장 넓은 방의 넓이

3. 하나의 벽을 제거하여 얻을 수 있는 가장 넓은 방의 크기

이렇게 됩니다.

저는 1, 2번은 각 방의 넘버링으로 해결하였고, 3번은 각 방에 인접한 방을 찾아서 해결하였습니다.

 

 

이 문제에서 입력으로 주어지는 숫자는 벽에 대한 정보입니다.

서쪽에 벽이 있으면 1, 북쪽에 벽이 있으면 2, 동쪽에 벽이 있으면 4, 남쪽에 벽이 있으면 8을 더한 값이 주어집니다.

만약에 벽이 없으면 하나도 더해지지 않은 0이 주어질 것이고, 사방에 모두 벽이 있으면 1 + 2 + 4 + 8 = 15가 주어질 것입니다.

 

1, 2, 4, 8을 더한 값이 주어지기 때문에 먼저 비트마스킹을 떠올렸습니다.

벽을 체크하기 위해 wall 배열에 해당 방향에 대한 값을 넣었고,

해당 방향을 체크할 때 해당하는 값인 wall[i]과 list[x][y]를 비교하여

list[x][y] & wall[i]이 0이면 벽이 없는 것이고, 0이 아니면 벽이 있는 것이라고 보시면 되겠습니다.

 

bfs & 비트마스킹으로 각 방에 넘버링을 하였고, 넘버링을 하면서 방의 크기도 같이 구하였습니다.

그 다음 bfs를 한번 더 돌려서 인접한 방 번호를 sideroom에 넣었고 방의 크기 + 인접한 방의 크기를 비교하여 최댓값을 출력하였습니다.

(sideroom을 set으로 한 이유는 중복체크를 하기 위함입니다.)

 

 

[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
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
#include <iostream>
#include <queue>
#include <algorithm>
#include <cstring>
#include <set>
using namespace std;
 
set<int> sideroom[2501];
int N, M, wall[4= { 4812 };
int list[50][50], direct[4][2= { {0,1}, {1,0}, {0,-1}, {-1,0} };
int roomnum, maxroomsize, Room[50][50], Roomsize[2501];
bool visit[50][50];
 
void sidechk(int sx, int sy, int num) {
    queue<pair<intint> > q;
    q.push({ sx, sy });
    visit[sx][sy] = true;
    while (!q.empty()) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
 
        for (int i = 0; i < 4; i++) {
            int nx = x + direct[i][0];
            int ny = y + direct[i][1];
 
            if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
            if (Room[nx][ny] != num) {
                sideroom[num].insert(Room[nx][ny]);
                continue;
            }
            if (visit[nx][ny]) continue;
 
            q.push({ nx, ny });
            visit[nx][ny] = true;
        }
    }
}
 
void bfs(int sx, int sy, int num) {
    queue<pair<intint> > q;
    q.push({ sx, sy });
    visit[sx][sy] = true;
    for (int t = 1; ; t++) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
 
        Room[x][y] = num;
 
        for (int i = 0; i < 4; i++) {
            if (wall[i] & list[x][y]) continue;
            int nx = x + direct[i][0];
            int ny = y + direct[i][1];
 
            if (visit[nx][ny]) continue;
            q.push({ nx, ny });
            visit[nx][ny] = true;
        }
 
        if (q.empty()) {
            Roomsize[num] = t;
            maxroomsize = max(maxroomsize, t);
            break;
        }
    }
}
 
void solve() {
    int maxroomsum = 0;
    cout << roomnum << '\n' << maxroomsize << '\n';
    for (int i = 1; i <= roomnum; i++) {
        set<int>:: iterator iter;
        for (iter = sideroom[i].begin(); iter != sideroom[i].end(); iter++) {
            int s = *iter;
 
            maxroomsum = max(maxroomsum, Roomsize[i] + Roomsize[s]);
        }
    }
 
    cout << maxroomsum << '\n';
}
 
void func() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (visit[i][j]) continue;
            bfs(i, j, ++roomnum);
        }
    }
    memset(visit, falsesizeof(visit));
 
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (visit[i][j]) continue;
            sidechk(i, j, Room[i][j]);
        }
    }
}
 
void input() {
    cin >> M >> N;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cin >> list[i][j];
        }
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    func();
    solve();
 
    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
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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Deque;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static int list[][] = new int[51][51];
    static int div[][] = new int[51][51];
    static boolean visit[][] = new boolean[51][51];
    static ArrayList<Integer> roomarea = new ArrayList<>();
    static Set<Integer> s[];
    static int wall[] = { 4812 };
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static int N, M, roomcnt, maxarea, cnt, ans;
 
    static void sidechk(int sx, int sy) {
        Deque<int[]> dq = new ArrayDeque<>();
        dq.add(new int[] { sx, sy });
        visit[sx][sy] = true;
        while (!dq.isEmpty()) {
            int x = dq.peek()[0];
            int y = dq.poll()[1];
 
            for (int i = 0; i < 4; i++) {
                int nx = x + direct[i][0];
                int ny = y + direct[i][1];
 
                if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                    continue;
                if (visit[nx][ny])
                    continue;
 
                if (div[x][y] != div[nx][ny])
                    s[div[x][y]].add(div[nx][ny]);
                else {
                    dq.add(new int[] { nx, ny });
                    visit[nx][ny] = true;
                }
            }
        }
    }
 
    static void solveroom(int sx, int sy) {
        Deque<int[]> dq = new ArrayDeque<>();
        dq.add(new int[] { sx, sy });
        visit[sx][sy] = true;
        while (!dq.isEmpty()) {
            int x = dq.peek()[0];
            int y = dq.poll()[1];
            div[x][y] = roomcnt;
            cnt++;
 
            for (int i = 0; i < 4; i++) {
                int nx = x + direct[i][0];
                int ny = y + direct[i][1];
 
                if (nx < 0 || ny < 0 || nx >= N || ny >= M)
                    continue;
                if (visit[nx][ny] || (wall[i] & list[x][y]) > 0)
                    continue;
 
                dq.add(new int[] { nx, ny });
                visit[nx][ny] = true;
            }
        }
    }
 
    static void func() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (visit[i][j])
                    continue;
                solveroom(i, j);
                roomarea.add(cnt);
                roomcnt++;
                maxarea = Math.max(maxarea, cnt);
                cnt = 0;
            }
        }
 
        s = new HashSet[roomcnt];
        for (int i = 0; i < roomcnt; i++)
            s[i] = new HashSet<>();
 
        for (int i = 0; i < N; i++)
            Arrays.fill(visit[i], false);
 
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                if (visit[i][j])
                    continue;
 
                sidechk(i, j);
            }
        }
    }
 
    static void solve() {
        for (int i = 0; i < roomcnt; i++) {
            Iterator<Integer> iter = s[i].iterator();
            while (iter.hasNext()) {
                ans = Math.max(ans, roomarea.get(i) + roomarea.get(iter.next()));
            }
        }
 
        System.out.println(roomcnt + "\n" + maxarea + "\n" + ans);
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        M = Integer.parseInt(st.nextToken());
        N = Integer.parseInt(st.nextToken());
 
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < M; j++) {
                list[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        solve();
    }
}
cs

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

boj 17142 연구소 3  (0) 2021.01.22
boj 2636 치즈  (0) 2021.01.22
boj 1039 교환  (0) 2021.01.22
boj 3055 탈출  (0) 2021.01.22
boj 17472 다리 만들기 2  (0) 2021.01.22

 

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

 

17472번: 다리 만들기 2

첫째 줄에 지도의 세로 크기 N과 가로 크기 M이 주어진다. 둘째 줄부터 N개의 줄에 지도의 정보가 주어진다. 각 줄은 M개의 수로 이루어져 있으며, 수는 0 또는 1이다. 0은 바다, 1은 땅을 의미한다.

www.acmicpc.net

BFS + MST 로 해결하는 문제입니다.

 

먼저 섬의 번호를 구분할 수 있게 표시하고,

섬의 한 지점에서 한방향으로 탐색을 하여 길이가 2이상인 다리를 놓을수 있는지 확인합니다.

 

놓을 수 있으면 시작 섬 번호, 도착 섬 번호, 길이를 벡터에 push_back을 하고,

길이가 2 미만이거나 놓을 수 없으면 빠져나와줍니다.

(여기서 chk 배열을 사용한건

섬 1에서 섬 2까지 연결하는데 같은길이의 다리를 2개 이상 놓을 수 있는 경우와

섬 1에서 섬 2까지 연결하는 것과 섬 2에서 섬 1까지 연결하는 것이 중복되기 때문에 사용하였습니다.)

 

이제 시작 섬 번호, 도착 섬 번호, 길이 정보가 담겨있는 벡터를 길이가 작은 순서대로 sort를 한 후에

크루스칼 알고리즘에서 작은 간선을 선택하는 방식처럼 작은 길이를 선택해주면서 parent 배열을 갱신합니다.

(parent 배열에는 해당 번호 섬의 root가 되는 섬의 번호가 저장되어 있으며, 어떤 섬과 연결되어 있는지 알 수 있습니다.)

 

ans가 0이면 -1을 출력하고 끝내면 되고, 아니면 답을 출력하면 되는데

중요한 것은 모든섬을 연결해야 한다는 것입니다. (그거 때문에 왜틀렸는지 오랫동안 고민해서 ㅠㅠ)

섬이 최대 6개이므로 선형으로 root가 같은지 체크를 한 후에 정답을 출력합니다.

 
1 6
1 0 0 1 0 1
 
//ans : -1
cs

 

문제풀이 하면서 찾은 반례 던지고 갑니다.

 

 

[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
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
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
 
typedef struct edge {
    int s;
    int e;
    int d;
}edge;
 
vector<edge> v;
int parent[11], N, M, ans, areadiv;
int list[10][10], direct[4][2= { {0,1}, {1,0}, {0,-1}, {-1,0} };
bool visit[10][10], chk[10][10][10];
 
bool cmp(edge a, edge b) {
    return a.d < b.d;
}
 
int find_parent(int u) {
    if (parent[u] == u) return u;
 
    return parent[u] = find_parent(parent[u]);
}
 
void union_find(int a, int b) {
    int aroot = find_parent(a);
    int broot = find_parent(b);
 
    parent[max(aroot, broot)] = min(aroot, broot);
}
 
void func() {
    for (int i = 0; i < v.size(); i++) {
        int s = v[i].s;
        int e = v[i].e;
        
        int sroot = find_parent(s);
        int eroot = find_parent(e);
 
        if (sroot == eroot) continue;
 
        union_find(sroot, eroot);
        ans += v[i].d;
    }
 
    if (!ans) {
        cout << "-1\n";
        return;
    }
 
    int root = find_parent(1);
    for (int i = 2; i <= areadiv; i++) {
        int next = find_parent(i);
        if (root != next) {
            ans = -1;
            break;
        }
    }
    cout << ans << '\n';
}
 
void dist(int x, int y, int di, int sn) {
    int xx = x;
    int yy = y;
    int cnt = 0;
 
    while (1) {
        int nx = xx + direct[di][0];
        int ny = yy + direct[di][1];
        
        if (nx < 0 || ny < 0 || nx >= N || ny >= M) break;
        if (list[nx][ny] == sn) break;
        if (!list[nx][ny]) {
            cnt++;
            xx = nx;
            yy = ny;
        }
        else if (list[nx][ny] != sn) {
            if (cnt < 2break;
            if (chk[sn][list[nx][ny]][cnt] || chk[list[nx][ny]][sn][cnt]) break;
            chk[sn][list[nx][ny]][cnt] = true;
            chk[list[nx][ny]][sn][cnt] = true;
            v.push_back({ sn, list[nx][ny], cnt });
            break;
        }
    }
 
    return;
}
 
void find_dist() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (list[i][j]) {
                for (int k = 0; k < 4; k++) {
                    dist(i, j, k, list[i][j]);
                }
            }
        }
    }
 
    sort(v.begin(), v.end(), cmp);
}
 
void bfs(int sx, int sy, int num) {
    queue<pair<intint> > q;
    q.push({ sx,sy });
    visit[sx][sy] = true;
 
    while (!q.empty()) {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
 
        list[x][y] = num;
 
        for (int i = 0; i < 4; i++) {
            int nx = x + direct[i][0];
            int ny = y + direct[i][1];
 
            if (nx < 0 || ny < 0 || nx >= N || ny >= M) continue;
            if (!list[nx][ny] || visit[nx][ny]) continue;
 
            q.push({ nx,ny });
            visit[nx][ny] = true;
        }
    }
}
 
void input() {
    cin >> N >> M;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            cin >> list[i][j];
         }
    }
 
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < M; j++) {
            if (visit[i][j] || !list[i][j]) continue;
 
            bfs(i, j, ++areadiv);
        }
    }
    for (int i = 1; i <= areadiv; i++) {
        parent[i] = i;
    }
}
 
int main() {
    cin.tie(NULL); cout.tie(NULL);
    ios::sync_with_stdio(false);
 
    input();
    find_dist();
    func();
 
    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
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
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.StringTokenizer;
 
public class Main {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer st;
    static ArrayList<int[]> edge = new ArrayList<>();
    static int list[][] = new int[11][11];
    static boolean visit[][] = new boolean[11][11];
    static boolean chk[][][] = new boolean[7][7][11];
    static int direct[][] = { { 01 }, { 10 }, { 0-1 }, { -10 } };
    static int parent[] = new int[7];
    static int N, M, cnt, div, ans;
 
    static int find(int v) {
        if (parent[v] == v)
            return v;
        return parent[v] = find(parent[v]);
    }
 
    static void Union(int u, int v, int w) {
        int a = find(u);
        int b = find(v);
 
        if (a == b)
            return;
 
        parent[b] = a;
        cnt++;
        ans += w;
    }
 
    static void solve() {
        Collections.sort(edge, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[2- o2[2];
            }
        });
 
        for (int i = 0; i < edge.size(); i++) {
            int x = edge.get(i)[0];
            int y = edge.get(i)[1];
            int dis = edge.get(i)[2];
 
            Union(x, y, dis);
        }
 
        if (cnt != div - 1)
            System.out.println(-1);
        else
            System.out.println(ans);
    }
 
    static void getDist(int sx, int sy, int d, int num) {
        int x = sx;
        int y = sy;
        int cnt = 0;
        while (true) {
            x += direct[d][0];
            y += direct[d][1];
            cnt++;
 
            if (x < 1 || y < 1 || x > N || y > M)
                break;
            if (list[x][y] == num)
                break;
            if (list[x][y] == 0)
                continue;
            if (list[x][y] != num) {
                if (cnt <= 2)
                    break;
                if (chk[num][list[x][y]][cnt])
                    break;
                chk[num][list[x][y]][cnt] = true;
                chk[list[x][y]][num][cnt] = true;
                edge.add(new int[] { num, list[x][y], cnt - 1 });
                return;
            }
        }
    }
 
    static void dist() {
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                if (list[i][j] != 0) {
                    for (int k = 0; k < 4; k++) {
                        getDist(i, j, k, list[i][j]);
                    }
                }
            }
        }
    }
 
    static void init() {
        for (int i = 1; i <= div; i++) {
            parent[i] = i;
        }
    }
 
    static void bfs(int sx, int sy) {
        Deque<int[]> dq = new ArrayDeque<>();
        dq.add(new int[] { sx, sy });
        visit[sx][sy] = true;
        while (!dq.isEmpty()) {
            int x = dq.peek()[0];
            int y = dq.poll()[1];
 
            list[x][y] = div;
 
            for (int i = 0; i < 4; i++) {
                int nx = x + direct[i][0];
                int ny = y + direct[i][1];
 
                if (nx < 1 || ny < 1 || nx > N || ny > M)
                    continue;
                if (visit[nx][ny] || list[nx][ny] == 0)
                    continue;
 
                dq.add(new int[] { nx, ny });
                visit[nx][ny] = true;
            }
        }
    }
 
    static void func() {
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= M; j++) {
                if (visit[i][j] || list[i][j] == 0)
                    continue;
 
                div++;
                bfs(i, j);
            }
        }
 
        init();
    }
 
    static void input() throws Exception {
        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        for (int i = 1; i <= N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 1; j <= M; j++) {
                list[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }
 
    public static void main(String[] args) throws Exception {
        input();
        func();
        dist();
        solve();
    }
}
cs

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

boj 17142 연구소 3  (0) 2021.01.22
boj 2636 치즈  (0) 2021.01.22
boj 1039 교환  (0) 2021.01.22
boj 3055 탈출  (0) 2021.01.22
boj 2234 성곽  (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/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

+ Recent posts