๋ฌธ์
์ฐจ์ธ๋ ์๋์ธ ํ๋๋ ๊ฐ์๋ ๊ณ ๋ญ์ง์์ ์ ๊ธฐ๋ ๋ฐฐ์ถ๋ฅผ ์ฌ๋ฐฐํ๊ธฐ๋ก ํ์๋ค. ๋์ฝ์ ์ฐ์ง ์๊ณ ๋ฐฐ์ถ๋ฅผ ์ฌ๋ฐฐํ๋ ค๋ฉด ๋ฐฐ์ถ๋ฅผ ํด์ถฉ์ผ๋ก๋ถํฐ ๋ณดํธํ๋ ๊ฒ์ด ์ค์ํ๊ธฐ ๋๋ฌธ์, ํ๋๋ ํด์ถฉ ๋ฐฉ์ง์ ํจ๊ณผ์ ์ธ ๋ฐฐ์ถํฐ์ง๋ ์ด๋ฅผ ๊ตฌ์ ํ๊ธฐ๋ก ๊ฒฐ์ฌํ๋ค. ์ด ์ง๋ ์ด๋ ๋ฐฐ์ถ๊ทผ์ฒ์ ์์ํ๋ฉฐ ํด์ถฉ์ ์ก์ ๋จน์์ผ๋ก์จ ๋ฐฐ์ถ๋ฅผ ๋ณดํธํ๋ค. ํนํ, ์ด๋ค ๋ฐฐ์ถ์ ๋ฐฐ์ถํฐ์ง๋ ์ด๊ฐ ํ ๋ง๋ฆฌ๋ผ๋ ์ด๊ณ ์์ผ๋ฉด ์ด ์ง๋ ์ด๋ ์ธ์ ํ ๋ค๋ฅธ ๋ฐฐ์ถ๋ก ์ด๋ํ ์ ์์ด, ๊ทธ ๋ฐฐ์ถ๋ค ์ญ์ ํด์ถฉ์ผ๋ก๋ถํฐ ๋ณดํธ๋ฐ์ ์ ์๋ค. ํ ๋ฐฐ์ถ์ ์ํ์ข์ฐ ๋ค ๋ฐฉํฅ์ ๋ค๋ฅธ ๋ฐฐ์ถ๊ฐ ์์นํ ๊ฒฝ์ฐ์ ์๋ก ์ธ์ ํด์๋ ๊ฒ์ด๋ค.
ํ๋๊ฐ ๋ฐฐ์ถ๋ฅผ ์ฌ๋ฐฐํ๋ ๋ ์ ๊ณ ๋ฅด์ง ๋ชปํด์ ๋ฐฐ์ถ๋ฅผ ๊ตฐ๋ฐ๊ตฐ๋ฐ ์ฌ์ด ๋์๋ค. ๋ฐฐ์ถ๋ค์ด ๋ชจ์ฌ์๋ ๊ณณ์๋ ๋ฐฐ์ถํฐ์ง๋ ์ด๊ฐ ํ ๋ง๋ฆฌ๋ง ์์ผ๋ฉด ๋๋ฏ๋ก ์๋ก ์ธ์ ํด์๋ ๋ฐฐ์ถ๋ค์ด ๋ช ๊ตฐ๋ฐ์ ํผ์ ธ์๋์ง ์กฐ์ฌํ๋ฉด ์ด ๋ช ๋ง๋ฆฌ์ ์ง๋ ์ด๊ฐ ํ์ํ์ง ์ ์ ์๋ค. ์๋ฅผ ๋ค์ด ๋ฐฐ์ถ๋ฐญ์ด ์๋์ ๊ฐ์ด ๊ตฌ์ฑ๋์ด ์์ผ๋ฉด ์ต์ 5๋ง๋ฆฌ์ ๋ฐฐ์ถํฐ์ง๋ ์ด๊ฐ ํ์ํ๋ค. 0์ ๋ฐฐ์ถ๊ฐ ์ฌ์ด์ ธ ์์ง ์์ ๋ ์ด๊ณ , 1์ ๋ฐฐ์ถ๊ฐ ์ฌ์ด์ ธ ์๋ ๋ ์ ๋ํ๋ธ๋ค.
1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 |
0 | 0 | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 1 |
0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 1 |
์ ๋ ฅ
์ ๋ ฅ์ ์ฒซ ์ค์๋ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T๊ฐ ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ ์ค๋ถํฐ ๊ฐ๊ฐ์ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ์ฒซ์งธ ์ค์๋ ๋ฐฐ์ถ๋ฅผ ์ฌ์ ๋ฐฐ์ถ๋ฐญ์ ๊ฐ๋ก๊ธธ์ด M(1 ≤ M ≤ 50)๊ณผ ์ธ๋ก๊ธธ์ด N(1 ≤ N ≤ 50), ๊ทธ๋ฆฌ๊ณ ๋ฐฐ์ถ๊ฐ ์ฌ์ด์ ธ ์๋ ์์น์ ๊ฐ์ K(1 ≤ K ≤ 2500)์ด ์ฃผ์ด์ง๋ค. ๊ทธ ๋ค์ K์ค์๋ ๋ฐฐ์ถ์ ์์น X(0 ≤ X ≤ M-1), Y(0 ≤ Y ≤ N-1)๊ฐ ์ฃผ์ด์ง๋ค. ๋ ๋ฐฐ์ถ์ ์์น๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ ์๋ค.
์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ํ์ํ ์ต์์ ๋ฐฐ์ถํฐ์ง๋ ์ด ๋ง๋ฆฌ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ ๋ต์ฝ๋
โ
#include <iostream>
#include <string.h>
using namespace std;
int M, N, K; // ๊ฐ๋ก, ์ธ๋ก, ์์น๊ฐ์
int field[50][50] = { 0 };
int visited[50][50] = { 0 };
int move_x[4] = {1, -1, 0, 0};
int move_y[4] = {0, 0, -1, 1};
void dfs(int x, int y) {
for (int t = 0; t < 4; t++) {
// ๊ฒ์ฌํ ๊ฐ์์ ์ธ์ ํ ๊ฐ์ผ๋ก ๋ณ๊ฒฝ!
int xx = move_x[t] + x;
int yy = move_y[t] + y;
if (xx < 0 || xx >= M || yy < 0 || yy >= N) continue; // ํ๋๋ฅผ ๋ฒ์ด๋ฌ์ ๊ฒฝ์ฐ
if (field[xx][yy] && !visited[xx][yy]) {
visited[xx][yy]++;
dfs(xx, yy);
}
}
}
int main() {
int T; // ํ
์คํธ ์ผ์ด์ค ๊ฐ์
int x, y;
int answer = 0;
cin >> T;
for (int test_cast = 0; test_cast < T; test_cast++) {
cin >> M >> N >> K;
answer = 0;
// ๋ฐฐ์ด ์ด๊ธฐํ
memset(visited, 0, sizeof(visited));
memset(field, 0, sizeof(field));
// ํ๋ ๋ง๋ค๊ธฐ
for (int i = 0; i < K; i++) {
cin >> x >> y;
field[x][y] = 1;
}
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
if (!visited[i][j] && field[i][j]) { // ๋ฐฉ๋ฌธํ์ง ์์๊ณ , ํ๋์ ๋ฐฐ์ถ๊ฐ ์ฌ์ด์ ธ์์
answer++;
visited[i][j]++;
dfs(i, j);
}
}
}
cout << answer << '\n';
}
}
๋ฌธ์ ํด์
๋ฌธ์ ์ ํ๋ก ๋ํ๋์๋ ํ๋์์ 1๋ก ํ์๋ ๋ถ๋ถ์ ํ๋์ ์์ญ์ผ๋ก ๋ณด๊ณ ์ด ๋ถ๋ถ์ ์๋ฅผ ์นด์ดํธํฉ๋๋ค.
์ ๋ ์ด ๋ฌธ์ ๋ฅผ ๊น์ด์ฐ์ ํ์์ผ๋ก ํ์ดํ์์ต๋๋ค.
๋จผ์ ์ ๋ ฅ๊ฐ์ ํด๋นํ๋ ์์น์ ๊ฐ์ 1๋ก ๋ณ๊ฒฝํฉ๋๋ค.
๋ค์์ผ๋ก ๋ชจ๋ ํ๋์ ์์ญ์ ํ์ํฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ 1๋ก ํ์๋ ๋ถ๋ถ์ ๋ง๋๊ฒ๋๋ฉด ๊ทธ ๋ถ๋ถ์ ์์์ผ๋ก ์ธ์ ํด์๋ 1๋ก ํ์๋ ๋ถ๋ถ์ ํ์ํฉ๋๋ค.
์ด๋ ํด๋น์์ญ์ ๋ฐฉ๋ฌธํ ์ ์ด ์์ด์ผ ํฉ๋๋ค.
๋ฐฉ๋ฌธํ ๊ณณ์ visited๋ผ๋ ๋ฐฐ์ด์ 0์ด ์๋ ๋ค๋ฅธ๊ฐ์ผ๋ก ๋ณ๊ฒฝํ์ฌ ํ์ํฉ๋๋ค.
ํ์ํ ์ ๋ฒ๋ ์ ๊ฐ์ ์ ์ฅํ answer๋ณ์์ ๊ฐ์ ์ฆ๊ฐ์ํต๋๋ค.
๊ทธ ์์น๋ฅผ ์์์ผ๋ก ๊น์ด์ฐ์ ํ์์ ์์ํฉ๋๋ค.
์กฐ๊ธ ๋ค๋ฅธ์ ์ ์ธ์ ํ ๋ถ๋ถ์ ํ์ธํด์ผํ๊ธฐ ๋๋ฌธ์ move_x์ move_y๋ผ๋ ๋ฐฐ์ด์ด ํ์ํฉ๋๋ค.
move_x[0]๊ณผ move_y[0]์ ๊ฐ์ด ๊ฐ๊ฐ 1๊ณผ 0์ผ๊ฒฝ์ฐ์๋ x์ถ๋ง 1 ์ฆ๊ฐ์ํค๊ธฐ ๋๋ฌธ์ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์นธ ์ด๋ํ ๋ถ๋ถ์ ํ์ธํ๋ ๊ฒ์ ๋๋ค.
๋ค๋ฅธ๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง๋ก 4๊ฐ์ ๊ฐ์ ์ ์ฅํ ๋ฐฐ์ด์ ํตํด ์ํ์ข์ฐ๋ฅผ ๊ฒ์ฌํฉ๋๋ค.
xx๋ผ๋ ๋ณ์์๋ ๋ด๊ฐ ๊ฒ์ฌ๋ฅผ ํ ์์น์ ๊ฐ + ์ํ์ข์ฐ์ค ํ๋ ์ ํํ ๊ฐ ์ ์ ์ฅํฉ๋๋ค.
yy๋ ๋ง์ฐฌ๊ฐ์ง๋ก ๋์ํฉ๋๋ค.
์ด๋ฌํ ๋ฐฉ์์ ํตํด ๊ฒ์ฌํ ์์น์ ์ธ์ ํ ๊ฐ์ ๊ฒ์ฌํ ์ ์์ต๋๋ค.
์ฒซ๋ฒ์งธ ์กฐ๊ฑด๋ฌธ์ ๊ฒ์ฌํ ๊ฐ์ด ํ๋๋ฅผ ๋ฒ์ด๋ฌ์ ๊ฒฝ์ฐ์ ํด๋นํ๋ ์กฐ๊ฑด์ ๋๋ค. ์ด๋๋ continue๋ฅผ ํตํด ๋ฐ๋ณต๋ฌธ์ ๋ฒ์ด๋ฉ๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋์ผํ๊ฒ ๊ฒ์ฌํ ์์ญ์ ๋ฐฉ๋ฌธํ์ง ์์๊ณ , ๊ฒ์ฌํ ์์ญ์ ๊ฐ์ด 1์ผ๊ฒฝ์ฐ
์ฌ๊ท๋ฅผ ํตํด ๋์ผํ๊ฒ ๊ฒ์ฌํฉ๋๋ค.
์ด๊ณผ์ ๋ฐ๋ณต!!.....
์ฌ๊ธฐ์ ๋ฉ์ธ์ ์๋ memset์ ์ด ๋ฌธ์ ๊ฐ T๋ผ๋ ๊ฐ์ ๋ฐ์ ์ฌ๋ฌ๋ฒ ๊ฒ์ฌ ํ ์ ์๊ฒ ํด์ผํ๊ธฐ ๋๋ฌธ์ ์๋ก์ด ์ผ์ด์ค์์๋ visited์ field ๋ฐฐ์ด์ด ์ด๊ธฐํ ๋์ด์ผ ํฉ๋๋ค.
์ด๋ memset๋ฅผ ํตํด ๊ฐํธํ๊ฒ ๋น์ธ ์ ์์ต๋๋ค.
memset(ํด๋น ๋ฐฐ์ด,์ด๋ค๊ฐ์ผ๋ก ์ด๊ธฐํ?,๋ฐฐ์ด์ ํฌ๊ธฐ)
์ฌ๊ธฐ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๋ณดํต sizeof๋ฅผ ์ด์ฉํ์ฌ ์ ๋ ๊ฒ ๊ฐ์ต๋๋น..
๊ทธ๋ฆฌ๊ณ ! ๋ชฐ๋๋ ์ ์ด์๋๋ฐ.. ๋๋ฒ์งธ ๋งค๊ฐ๋ณ์๊ฐ 0์ด๋ฉด ์ด 0์ intํ์ด ์๋ string์ผ๋ก ์ด๊ธฐํ๊ฐ ๋ฉ๋๋ค.
๋ฐ๋ผ์ #include <string.h>๋ฅผ ์ ์ธํ์ง ์์ผ๋ฉด ์๋ฉ๋๋น..!!
๊ทธ๋์ ํ๋ฒ ํ๋ ธ์์ต๋๋ค..ใ ใ ใ
'Computer Science > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ํผ๋ณด๋์น ์์ด์ ๊ตฌํํ๋ ์ฌ๋ฌ๊ฐ์ง ๋ฐฉ๋ฒ (0) | 2022.12.29 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ๊ฐ ์๋ฆฌ ์์ ํฉ ๊ตฌํ๊ธฐ (0) | 2022.09.15 |
[๋ฐฑ์ค/Baekjoon] 16953๋ฒ A->B (C++) (0) | 2022.05.19 |