๋ฌธ์
๋๊ธ์ ๊ฐ๊ฒฉ์ด 1์ธ M×N(M,N≤100)ํฌ๊ธฐ์ ๋ชจ๋์ข ์ด๊ฐ ์๋ค. ์ด ๋ชจ๋์ข ์ด ์์ ๋๊ธ์ ๋ง์ถ์ด K๊ฐ์ ์ง์ฌ๊ฐํ์ ๊ทธ๋ฆด ๋, ์ด๋ค K๊ฐ์ ์ง์ฌ๊ฐํ์ ๋ด๋ถ๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋ถ๋ถ์ด ๋ช ๊ฐ์ ๋ถ๋ฆฌ๋ ์์ญ์ผ๋ก ๋๋์ด์ง๋ค.
์๋ฅผ ๋ค์ด M=5, N=7 ์ธ ๋ชจ๋์ข ์ด ์์ <๊ทธ๋ฆผ 1>๊ณผ ๊ฐ์ด ์ง์ฌ๊ฐํ 3๊ฐ๋ฅผ ๊ทธ๋ ธ๋ค๋ฉด, ๊ทธ ๋๋จธ์ง ์์ญ์ <๊ทธ๋ฆผ 2>์ ๊ฐ์ด 3๊ฐ์ ๋ถ๋ฆฌ๋ ์์ญ์ผ๋ก ๋๋์ด์ง๊ฒ ๋๋ค.
M, N๊ณผ K ๊ทธ๋ฆฌ๊ณ K๊ฐ์ ์ง์ฌ๊ฐํ์ ์ขํ๊ฐ ์ฃผ์ด์ง ๋, K๊ฐ์ ์ง์ฌ๊ฐํ ๋ด๋ถ๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋ถ๋ถ์ด ๋ช ๊ฐ์ ๋ถ๋ฆฌ๋ ์์ญ์ผ๋ก ๋๋์ด์ง๋์ง, ๊ทธ๋ฆฌ๊ณ ๋ถ๋ฆฌ๋ ๊ฐ ์์ญ์ ๋์ด๊ฐ ์ผ๋ง์ธ์ง๋ฅผ ๊ตฌํ์ฌ ์ด๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ์ด
์ฒดํฌ ํฌ์ธํธ 1
์ฒ์์๋ ์ฃผ์ด์ง ์ด๋ฏธ์ง์ฒ๋ผ ์ข์ธก ํ๋จ ์ขํ๋ถํฐ ์ฐ์ธก ์๋จ ์ขํ ์ฌ์ด์ ํฌํจ๋ ๋ชจ๋ ์ขํ์ ํ๋๊ทธ ์ฒ๋ฆฌ๋ฅผ ํ์๋ค.
์์ ๊ฐ์ด ์ฒ๋ฆฌ๋ฅผ ํ์ ๋, ์ง์ฌ๊ฐํ๊ณผ ๋ง์ฃผํ๋ ์์ญ์ ๋ชจ์๋ฆฌ๊ฐ ๊ฒน์น๊ฒ ๋๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์ ์ง์ฌ๊ฐํ์ ํ๋๊ทธ๋ฅผ ์ธ์ธ ๋, ์์ ์ด๋ฏธ์ง์ ๋ชจ์๋ฆฌ๋ง๋ค ํ๋๊ทธ๋ฅผ ์ธ์ฐ๋ ๊ฒ์ด ์๋๋ผ ๊ฐ์ ํ๋๋ฅผ ์ค์ฌ ์ ์ฌ๊ฐํ์ด ์ด์ด์ง ํํ๊ฐ ์๋ ๋ผ์ธ ํํ๋ก ๋ง๋ค์ด์ผ ํ๋ค.
๋ผ์ธ ํํ๋ก ์ค์ธ๋ค๋ ๋ง์, ์ฃผ์ด์ง ์ง์ฌ๊ฐํ ์ขํ๋ฅผ ๋ง๋ค ๋ ์ด์ค for ๋ฌธ์ ์ฐ์ธก ์๋จ ์ขํ ์ด์ ๊น์ง ๋ฐ๋ณตํ๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค.
์ด๋ ๊ฒ ํ๋ฉด ์ผ๋ฐ์ ์ธ DFS ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ง์ฌ๊ฐํ ์ด์ธ์ ์์ญ์ ๊ฐ์๋ฅผ ํ์ ํ ์ ์๋ค.
์ฒดํฌ ํฌ์ธํธ 2
์ง์ฌ๊ฐํ ์ด์ธ์ ์์ญ์ ๊ฐ์๋ฅผ ํ์ ํ๋ค๋ฉด ํด๋น ์์ญ์ ํฌํจ๋ ์ ์ ์ ๊ฐ์๋ฅผ ํ์ ํด์ผ ํ๋ค.
๋๋ ์ฌ๊ทํจ์๋ฅผ ๋ ๋ ํด๋น ๊ฐ์ ๋ํ๊ณ ์ฌ๊ท ๋ด๋ถ์์ ์ํ์ข์ฐ๋ฅผ ๋๋ฉฐ ํธ์ถํ๋ dfs()
ํจ์์ ๋ฆฌํด๊ฐ์
์ต์ด ํธ์ถํ dfs()
์์ ๊ฐ์ ๊ฐฑ์ ํ๊ณ ๋ฆฌํดํ๋๋ก ํ๋ฉด ํด๋น ์์ญ์ ํฌํจ๋ ์ ์ ์ ๊ฐ์๋ฅผ ํ์
ํ ์ ์๋๋ก ํ๋ค.
๋ฉ๋ชจ
์ฒ์์ ๋ฌธ์ ๋ฅผ ํ ๋๋ ์ด์ฐ์ ์ฐ ํ๋ฆด ๋ฏ ํ๋ค๊ฐ๋ ์๋ํ๋๋ก ์ฝ๋๊ฐ ๋์๊ฐ์ง ์์์ ์ฒ์๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ ์๋ก ์์ฑ ํ๋๋ฐ, ์ญ์ ๊ธํ ์๋ก ๋์๊ฐ๋ผ๋ ๋ง์ด ๋ง๋ ๋ฏ ํ๋ค.
์กฐ๊ธ ๋งํ ๋๋ ๊ธํ์ง ์๊ฒ ์ฒ์๋ถํฐ ์ฐจ๊ทผ์ฐจ๊ทผ ์ฝ์ด๋ณด๋๋ก ํ์.
#include <bits/stdc++.h>
using namespace std;
int m, n, k;
int adj[104][104], visited[104][104];
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
int dfs(int y, int x, int c) {
visited[y][x] = 1;
for (int i = 0; i < 4; i++) {
int ny = y + dy[i];
int nx = x + dx[i];
if (ny < 0 || nx < 0 || ny >= m || nx >= n) continue;
if (!adj[ny][nx] && !visited[ny][nx]) {
c = dfs(ny, nx, ++c);
}
}
return c;
}
int main() {
cin >> m >> n >> k;
for (int i = 0; i < k; i++) {
int corner[4];
for (int j = 0; j < 4; j++) cin >> corner[j];
for (int y = corner[1]; y < corner[3]; y++) {
for (int x = corner[0]; x < corner[2]; x++) {
adj[y][x] = 1;
}
}
}
int cnt = 0;
vector<int> areas;
for (int y = 0; y < m; y++) {
for (int x = 0; x < n; x++) {
if (!adj[y][x] && !visited[y][x]) {
cnt++;
areas.push_back(dfs(y, x, 1));
}
}
}
sort(areas.begin(), areas.end());
cout << cnt << '\n';
for (int area : areas) {
cout << area << " ";
}
}
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค 2468] ์์ ์์ญ (0) | 2023.05.10 |
---|---|
[๋ฐฑ์ค 1012] ์ ๊ธฐ๋ ๋ฐฐ์ถ (0) | 2023.05.08 |
[๋ฐฑ์ค 4375] 1 (0) | 2023.04.23 |
[๋ฐฑ์ค 3986] ์ข์ ๋จ์ด (0) | 2023.04.18 |
[๋ฐฑ์ค 1940] ์ฃผ๋ชฝ (0) | 2023.04.17 |