반응형

www.acmicpc.net/problem/12946

 

12946번: 육각 보드

크기가 N × N인 육각 보드가 주어진다. 아래 그림은 N = 1, 2, 3, 4인 경우의 그림이다. 육각 보드의 일부 칸을 색칠하려고 한다. 두 칸이 변을 공유하는 경우에는 같은 색으로 칠할 수 없다. 어떤 칸

www.acmicpc.net

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
if (direction != -1) {                     // dfs 첫 실행 시, 이동한 방향 없으므로 -1로 설정. 
    // 인접한 두 칸만 확인                 // -1이 아니면 이전 칸에서 현재 칸으로 이동했음을 의미
    int chk1 = (direction + 2) % 6;
    int chk2 = (direction + 4) % 6;
        
    // 첫 번째 칸 확인
    int nx1 = x + dx[chk1];
    int ny1 = y + dy[chk1];
    if (nx1 > 0 && nx1 <= n && ny1 > 0 && ny1 <= n && arr[nx1][ny1] == 'X') {
        cout << 3;
        exit(0);
    }
 
    // 두 번째 칸 확인
    int nx2 = x + dx[chk2];
    int ny2 = y + dy[chk2];
    if (nx2 > 0 && nx2 <= n && ny2 > 0 && ny2 <= n && arr[nx2][ny2] == 'X') {
        cout << 3;
        exit(0);
    }
}
cs
1
2
3
4
5
6
7
8
9
10
11
if (visited[nx][ny]) {                         // 다음 칸 이미 방문 했으면 (고리 형성 됐으면)
    if (visited[x][y] == visited[nx][ny]) {    // 현재 칸과 다음 칸 색깔이 같으면
        cout << 3;                             // 색깔 하나 더 사용해야 함 (3개)
        exit(0);
    }
}
else {                                        // 다음 칸 방문 안했으면
    ans = 2;                                 // 색깔 2개만 있으면 됨
    int next_val = (val == 1) ? 2 : 1;        // 현재 색과 다른 색으로 변경
   dfs(nx, ny, i, next_val);                // 다음 탐색
}
cs

 

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
#include <iostream>
#include <algorithm>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int n, ans;
int dx[] = {-1-10110 };
int dy[] = {0110-1-1 };
char arr[51][51];
int visited[51][51];                                // 0: 방문 안함, 1: 첫 번째 색깔, 2: 두 번째 색깔
 
void dfs(int x, int y, int direction, int val) {    // direction: 이전 칸 -> 현재 칸 어떤 방향으로 이동했는가?
    visited[x][y] = val;                            // visited[][]에 현재 색깔 칠하기
    if (direction != -1) {                            // dfs 첫 실행 시, 이동한 방향 없으므로 -1로 설정. 
        // 인접한 두 칸만 확인                        // -1이 아니면 이전 칸에서 현재 칸으로 이동했음을 의미
        int chk1 = (direction + 2) % 6;
        int chk2 = (direction + 4) % 6;
        
        // 첫 번째 칸 확인
        int nx1 = x + dx[chk1];
        int ny1 = y + dy[chk1];
        if (nx1 > 0 && nx1 <= n && ny1 > 0 && ny1 <= n && arr[nx1][ny1] == 'X') {
            cout << 3;
            exit(0);
        }
 
        // 두 번째 칸 확인
        int nx2 = x + dx[chk2];
        int ny2 = y + dy[chk2];
        if (nx2 > 0 && nx2 <= n && ny2 > 0 && ny2 <= n && arr[nx2][ny2] == 'X') {
            cout << 3;
            exit(0);
        }
    }
 
    // 인접한 6방향 탐색
    rep(i,6) {
        if ((i+3)%6 == direction) continue;                // 바로 이전 방향으로 되돌아가지 않도록
        int nx = x + dx[i];
        int ny = y + dy[i];
        
        // 연결된 칸 있으면
        if (nx > 0 && nx <= n && ny > 0 && ny <= n && arr[nx][ny] == 'X') {
            if (visited[nx][ny]) {                        // 다음 칸 이미 방문 했으면 (고리 형성 됐으면)
                if (visited[x][y] == visited[nx][ny]) {    // 현재 칸과 다음 칸 색깔이 같으면
                    cout << 3;                            // 색깔 하나 더 사용해야 함 (3개)
                    exit(0);
                }
            }
            else {                                        // 다음 칸 방문 안했으면
                ans = 2;                                // 색깔 2개만 있으면 됨
                int next_val = (val == 1) ? 2 : 1;        // 현재 색과 다른 색으로 변경
                dfs(nx, ny, i, next_val);                // 다음 탐색
            }
        }
    }
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    rep(i, n) {
        rep(j, n)
            cin >> arr[i][j];
    }
 
    rep(i, n) {
        rep(j, n) {
            if (arr[i][j] == 'X' && !visited[i][j]) {
                ans = max(ans, 1);        // 첫 번째 dfs 호출 시 ans = 2로 바꿨는데
                dfs(i, j, -11);        // 두 번째 dfs 호출 시 ans = 1일 경우 덮어쓰지 않기 위해서 ans = max(ans, 1) 
            }
        }
    }
    cout << ans;
}
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 16940 [복습 필수]  (0) 2021.03.10
백준 16929  (0) 2021.03.06
백준 16947 [복습 필수]  (0) 2021.03.06
백준 16197  (0) 2021.02.23
백준 13549  (0) 2021.02.19
반응형

www.acmicpc.net/problem/16940

 

16940번: BFS 스페셜 저지

올바른 순서는 1, 2, 3, 4와  1, 3, 2, 4가 있다.

www.acmicpc.net

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
while (!q.empty()) {
        int now = q.front();
        q.pop();
 
        cnt = 0;
        for (int next : v[now]) {
            if (!visited[next]) {
                visited[next] = 1;        // 방문 처리
                q.push(next);            // 일단 넣기
                cnt++;
            }
        }
 
        for (int i = idx; i < idx + cnt; i++) {
            if (!visited[arr[i]]) {        // 순서대로 방문하지 않았으면
                cout << 0;
                exit(0);
            }
        }
 
        idx += cnt;
    }
cs

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
while (!q.empty()) {
        int now = q.front();
        q.pop();
 
        cnt = 0;    
        for (int next : v[now]) {
            if (!visited[next]) {
                visited[next] = 1;        // 방문 처리
                cnt++;
            }
        }
 
        for (int i = idx; i < idx + cnt; i++) {
            if (!visited[arr[i]]) {        // 순서대로 방문하지 않았으면
                cout << 0;
                return 0;
            }
            q.push(arr[i]);                // 순서대로 큐에 
        }
        idx += cnt;
    }
cs

 

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
#include <iostream>
#include <queue>
#include <vector>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
queue<int> q;
vector<vector<int> > v;
bool visited[100001];
int n, a, b, arr[100001];
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    v.resize(n + 1);
    rep(i, n - 1) {
        cin >> a >> b;
        v[a].push_back(b);
        v[b].push_back(a);
    }
    rep(i, n)
        cin >> arr[i];
 
    if (arr[0!= 1) {
        cout << 0;
        exit(0);
    }
    int idx = 1;
    visited[1= 1;
    q.push(1);
    int cnt = 0;
    while (!q.empty()) {
        int now = q.front();
        q.pop();
 
        cnt = 0;                    // 연결된 자식 노드 수
        for (int next : v[now]) {
            if (!visited[next]) {
                visited[next] = 1;    // 방문 처리
                cnt++;
            }
        }
        for (int i = idx; i < idx + cnt; i++) {
            if (!visited[arr[i]]) {    // 순서대로 방문하지 않았으면
                cout << 0;
                exit(0);
            }
            q.push(arr[i]);            // 순서대로 큐에 삽입
        }
        idx += cnt;
    }
    cout << 1;
}
 
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 12946 [복습 필수]  (0) 2021.03.11
백준 16929  (0) 2021.03.06
백준 16947 [복습 필수]  (0) 2021.03.06
백준 16197  (0) 2021.02.23
백준 13549  (0) 2021.02.19
반응형

www.acmicpc.net/problem/16929

 

16929번: Two Dots

첫째 줄에 게임판의 크기 N, M이 주어진다. 둘째 줄부터 N개의 줄에 게임판의 상태가 주어진다. 게임판은 모두 점으로 가득차 있고, 게임판의 상태는 점의 색을 의미한다. 점의 색은 알파벳 대문

www.acmicpc.net

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
#include <iostream>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int n, m;
int dx[] = { -1100 };
int dy[] = { 00-11 };
int visited[50][50];
char arr[50][50];
void dfs(int x, int y, char c, int ban_direc) {
    // 방문한 곳 또 방문했으면 성공
    if (visited[x][y]) {
        cout << "Yes";
        exit(0);
    }
    visited[x][y] = 1;
 
    rep(i, 4) {
        // 반대 방향으로 못 가도록 설정
        if (i == ban_direc) continue;
 
        int nx = x + dx[i];
        int ny = y + dy[i];
        if (nx >= 0 && nx < n && ny >= 0 && ny < m && c == arr[nx][ny]) {
            // 이동하면 안되는 방향 설정 (현재와 반대 방향)
            int ban = 0;
            if (i == 0) ban = 1;
            else if (i == 1) ban = 0;
            else if (i == 2) ban = 3;
            else if (i == 3) ban = 2;
            dfs(nx, ny, arr[nx][ny], ban);
        }
    }
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    rep(i, n) {
        rep(j, m)
            cin >> arr[i][j];
    }
    rep(i, n) {
        rep(j, m) {
            if (!visited[i][j])
                dfs(i, j, arr[i][j], 0);    // (row, col, 현재문자, 이동 금지 방향)
        }
    }
    cout << "No";
}
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 12946 [복습 필수]  (0) 2021.03.11
백준 16940 [복습 필수]  (0) 2021.03.10
백준 16947 [복습 필수]  (0) 2021.03.06
백준 16197  (0) 2021.02.23
백준 13549  (0) 2021.02.19
반응형

www.acmicpc.net/problem/16947

 

16947번: 서울 지하철 2호선

첫째 줄에 역의 개수 N(3 ≤ N ≤ 3,000)이 주어진다. 둘째 줄부터 N개의 줄에는 역과 역을 연결하는 구간의 정보가 주어진다. 같은 구간이 여러 번 주어지는 경우는 없고, 역은 1번부터 N번까지 번호

www.acmicpc.net

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
int dfs(int now, int before) {
    if (visited[now] == 1)    // 사이클 찾았으면
        return now;            // 현재 노드 리턴
    visited[now] = 1;        // 방문 처리
 
    for (int next : v[now]) {            // 연결된 노드 탐색
        if (next == before) continue;    // 바로 전으로 돌아가면 패스
 
        ret = dfs(next, now);            // 다음 탐색
 
        if (ret > 0) {                // 사이클 시작점 찾았으면
            visited[now] = 2;        // 사이클에 포함 시킴
 
            if (now == ret)            // 사이클 시작점까지 도착 -> 나머지는 사이클에 포함 안됨
                return -1;                    //   -> -1 리턴
            else 
                return ret;            // 사이클 시작점
        }
 
        if (ret == -1)
            return -1;
    }
    return 0;        // 못찾았으면 0 리턴
}
cs

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
rep(i,n) {
    if (visited[i] == 2) {    // 사이클에 포함된 경우
        dist[i] = 0;        // 사이클과의 거리는 0
        q.push(i);
    }
    else
        dist[i] = -1;        // 사이클에 포함 안되면 -1
}
 
while (!q.empty()) {    // bfs로 사이클과의 거리를 구함
    int now = q.front();
    q.pop();
    for(int next : v[now]) {
        if (dist[next] == -1) {    // 다음 노드가 사이클에 포함되어있지 않다면
            q.push(next);
            dist[next] = dist[now] + 1;
        }
    }
}
cs

 

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
#include <iostream>
#include <cstring>
#include <vector>
#include <queue>
#define rep(i,n) for(int i=1;i<=n;i++)
using namespace std;
vector<vector<int> > v;
int n, a, b;
int visited[3001];    // 0: not visited, 1: visited, 2: cycle
int dist[3001];        // 사이클로부터의 거리
int ret;
int dfs(int now, int before) {
    if (visited[now] == 1)    // 사이클 찾았으면
        return now;            // 현재 노드 리턴
    visited[now] = 1;        // 방문 처리
 
    for (int next : v[now]) {            // 연결된 노드 탐색
        if (next == before) continue;    // 바로 전으로 돌아가면 패스
 
        ret = dfs(next, now);            // 다음 탐색
 
        if (ret > 0) {                // 사이클 시작점 찾았으면
            visited[now] = 2;        // 사이클에 포함 시킴
 
            if (now == ret)            // 사이클 시작점까지 도착 -> 나머지는 사이클에 포함 안됨
                return -1;                    //   -> -1 리턴
            else 
                return ret;            // 사이클 시작점
        }
 
        if (ret == -1)
            return -1;
    }
    return 0;        // 못찾았으면 0 리턴
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    v.resize(n + 1);
    fill(dist, dist + n + 1987654321);
 
    rep(i, n) {
        cin >> a >> b;
        v[a].push_back(b);
        v[b].push_back(a);
    }
 
    dfs(1-1);
    queue<int> q;
    rep(i,n) {
        if (visited[i] == 2) {    // 사이클에 포함된 경우
            dist[i] = 0;        // 사이클과의 거리는 0
            q.push(i);
        }
        else
            dist[i] = -1;        // 사이클에 포함 안되면 -1
    }
 
    while (!q.empty()) {    // bfs로 사이클과의 거리를 구함
        int now = q.front();
        q.pop();
        for(int next : v[now]) {
            if (dist[next] == -1) {    // 다음 노드가 사이클에 포함되어있지 않다면
                q.push(next);
                dist[next] = dist[now] + 1;
            }
        }
    }
 
    rep(i,n)
        cout << dist[i] << ' ';
}
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 16940 [복습 필수]  (0) 2021.03.10
백준 16929  (0) 2021.03.06
백준 16197  (0) 2021.02.23
백준 13549  (0) 2021.02.19
백준 14226 [복습 필수]  (0) 2021.02.19
반응형

www.acmicpc.net/problem/16197

 

16197번: 두 동전

N×M 크기의 보드와 4개의 버튼으로 이루어진 게임이 있다. 보드는 1×1크기의 정사각형 칸으로 나누어져 있고, 각각의 칸은 비어있거나, 벽이다. 두 개의 빈 칸에는 동전이 하나씩 놓여져 있고,

www.acmicpc.net

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
#include <iostream>
#include <queue>
#define pii pair<intint>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int n, m;
char arr[21][21];
int dx[] = { 00-11 };
int dy[] = { -1100 };
bool visited[20][20][20][20];
queue<pii> q;
void bfs() {
    int cnt = 1;
    while (!q.empty()) {
        int size = q.size() / 2;    // 한 번에 두 개 꺼냄
        while (size--){
            if (cnt > 10)            // 10번 초과하면 불가
                return;
            pii c1 = q.front();
            q.pop();
            pii c2 = q.front();
            q.pop();
 
            if (c1 == c2)            // 두 동전이 겹치면 패스
                continue;
 
            rep(i, 4) {
                int nx1 = c1.first + dx[i];
                int ny1 = c1.second + dy[i];
                int nx2 = c2.first + dx[i];
                int ny2 = c2.second + dy[i];
 
                bool drop1 = false;
                bool drop2 = false;
                if (nx1 < 0 || nx1 >= n || ny1 < 0 || ny1 >= m)
                    drop1 = true;
                if (nx2 < 0 || nx2 >= n || ny2 < 0 || ny2 >= m)
                    drop2 = true;
 
                if (drop1 && drop2)    // 둘 다 떨어지면 패스
                    continue;
 
                else if ((drop1 && !drop2) || (!drop1 && drop2)) {    // 하나만 떨어짐
                    cout << cnt;
                    exit(0);
                }
 
                if (arr[nx1][ny1] == '#' && arr[nx2][ny2] == '#'continue// 둘 다 벽이면 패스
 
                if (arr[nx1][ny1] != '#' && arr[nx2][ny2] != '#') {            // 둘 다 벽 아니면 이동
                    if (!visited[nx1][ny1][nx2][ny2]) {
                        q.push({ nx1, ny1 });
                        q.push({ nx2, ny2 });
                        visited[nx1][ny1][nx2][ny2] = 1;
                    }
                }
                else if(arr[nx1][ny1] == '#' && arr[nx2][ny2] != '#') {        // 둘 중 하나가 벽이면
                    if (!visited[c1.first][c1.second][nx2][ny2]) {            
                        q.push(c1);                                            // 벽이면 제자리 삽입
                        q.push({ nx2, ny2 });                                // 벽 아니면 다음 위치 삽입
                        visited[c1.first][c1.second][nx2][ny2] = 1;
                    }
                }
                else if (arr[nx1][ny1] != '#' && arr[nx2][ny2] == '#') {
                    if (!visited[nx1][ny1][c2.first][c2.second]) {
                        q.push({ nx1, ny1 });
                        q.push(c2);
                        visited[nx1][ny1][c2.first][c2.second] = 1;
                    }
                }
                    
            }
        }
        cnt++;
    }
}
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    rep(i, n) {
        rep(j, m) {
            cin >> arr[i][j];
            if (arr[i][j] == 'o'
                q.push({ i, j });
        }
    }
    if (q.size() == 1) {    // 입력된 동전 위치가 하나 -> 두 개의 동전이 겹침
        cout << -1;
        exit(0);
    }
    bfs();
    cout << -1;
}
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 16929  (0) 2021.03.06
백준 16947 [복습 필수]  (0) 2021.03.06
백준 13549  (0) 2021.02.19
백준 14226 [복습 필수]  (0) 2021.02.19
백준 13913  (0) 2021.02.19
반응형

www.acmicpc.net/problem/13549

 

13549번: 숨바꼭질 3

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일

www.acmicpc.net

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
#include <iostream>
#include <queue>
using namespace std;
int n, k, cnt;
bool visited[200001];
queue<int> q;
bool valid(int x) {
    if (x >= 0 && x <= 100000)
        return true;
    return false;
}
void insert(int x) {
    if (!valid(x)) return;
    if (!visited[x]) {
        q.push(x);
        visited[x] = 1;
    }
}
 
void teleport(int n) {            // 순간이동 할 수 있는 위치 (n*2) 모두 삽입
    if (!valid(n)) return;
    for (int i = n; i <= 100000; i *= 2) {
        if (!visited[i]) {
            q.push(i);
            visited[i] = 1;
        }
        if (i == 0break;        // 0일 때 순간이동 못함 -> 무한루프
    }
}
void bfs(int n) {
    teleport(n);
    while (!q.empty()) {
        int size = q.size();
        while (size--) {
            int now = q.front();
            q.pop();
            if (now == k) {
                cout << cnt;
                return;
            }
            insert(now - 1);    // 앞으로 이동
            insert(now + 1);    // 뒤로 이동
 
            teleport(now - 1);    // 앞에서 순간이동 할 수 있는 위치 모두 삽입
            teleport(now + 1);    // 뒤에서 순간이동 할 수 있는 위치 모두 삽입
        }
        cnt++;
    }
}
int main() {
    cin >> n >> k;
    bfs(n);
}
cs

 

반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 16947 [복습 필수]  (0) 2021.03.06
백준 16197  (0) 2021.02.23
백준 14226 [복습 필수]  (0) 2021.02.19
백준 13913  (0) 2021.02.19
백준 2178  (0) 2021.02.19
반응형

www.acmicpc.net/problem/14226

 

14226번: 이모티콘

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

www.acmicpc.net

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
// https://yabmoons.tistory.com/74
#include <iostream>
#include <queue>
#define pii pair<intint>
using namespace std;
int n, cnt;
bool visited[1001][1001];
queue<pii> q;
void bfs(int i, int j) {
    visited[i][j] = 1;
    q.push({ i,j });
    while (!q.empty()) {
        int size = q.size();
        cnt++;
        while (size--) {
            int screen = q.front().first;
            int clipboard = q.front().second;
            q.pop();
            if (screen == n) {        // 화면 이모티콘 n개 되면 종료
                cout << cnt;
                return;
            }
            // 1. 복사
            if (!visited[screen][screen]) {
                visited[screen][screen] =1;
                q.push({ screen, screen });
            }
            // 2. 붙여넣기
            if (screen + clipboard <= 1000 && !visited[screen + clipboard][clipboard]) {
                visited[screen + clipboard][clipboard] =1;
                q.push({ screen + clipboard, clipboard });
            }
            // 3. 삭제
            if (screen > 0 && !visited[screen - 1][clipboard]) {
                visited[screen - 1][clipboard] = 1;
                q.push({ screen - 1, clipboard });
            }
        }
    }
}
int main() {
    cin >> n;
    bfs(11);
}
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 16197  (0) 2021.02.23
백준 13549  (0) 2021.02.19
백준 13913  (0) 2021.02.19
백준 2178  (0) 2021.02.19
백준 1707  (0) 2021.02.19
반응형

www.acmicpc.net/problem/13913

 

13913번: 숨바꼭질 4

수빈이는 동생과 숨바꼭질을 하고 있다. 수빈이는 현재 점 N(0 ≤ N ≤ 100,000)에 있고, 동생은 점 K(0 ≤ K ≤ 100,000)에 있다. 수빈이는 걷거나 순간이동을 할 수 있다. 만약, 수빈이의 위치가 X일

www.acmicpc.net

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
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
// 10만보다 더 큰 곳으로 가서 -1 해서 갈 수도 있음
int n, k, now, visited[200001], parent[200001];
queue<int> q;
stack<int> s;
bool valid(int n) {
    if (!visited[n] && n >= 0 && n <= 100000)
        return true;
    return false;
}
void insert(int n) {
    if (valid(n)) {
        parent[n] = now;
        visited[n] = 1;
        q.push(n);
    }
}
void print() {
    while (now != -1) {
        s.push(now);        // 역순으로 출력하기 위해 stack 사용
        now = parent[now];    // 부모 따라서 계속 감
    }
    while (!s.empty()) {
        cout << s.top() << ' ';
        s.pop();
    }
}
 
void bfs(int start, int cnt) {
    parent[start] = -1;
    visited[start] = 1;
    q.push(start);
    while (!q.empty()) {
        cnt++;
        // 단계별로 진행
        int size = q.size();
        while (size--) {
            now = q.front();
            q.pop();
            
            if (now == k) {                // 동생 찾았으면 출력
                cout << cnt << '\n';
                print();
                exit(0);
            }
 
            insert(now - 1);            // Queue에 넣을 때 부모 정보 입력
            insert(now + 1);
            insert(now * 2);
        }
    }
}
int main() {
    cin >> n >> k;
    
    bfs(n, -1);
}
cs
반응형

'백준 > DFS, BFS' 카테고리의 다른 글

백준 13549  (0) 2021.02.19
백준 14226 [복습 필수]  (0) 2021.02.19
백준 2178  (0) 2021.02.19
백준 1707  (0) 2021.02.19
백준 13023  (0) 2021.02.19

+ Recent posts