๋ฌธ์
๋ก๊ณ ๋ ์ฃผ๋ก ๊ต์ก์ฉ์ ์ฐ์ด๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ค. ๋ก๊ณ ์ ๊ฐ์ฅ ํฐ ํน์ง์ ๊ฑฐ๋ถ์ด ๋ก๋ด์ธ๋ฐ, ์ฌ์ฉ์๋ ์ด ๊ฑฐ๋ถ์ด ๋ก๋ด์ ์์ง์ด๋ ๋ช ๋ น์ ์ ๋ ฅํด ํ๋ฉด์ ๋ํ์ ๊ทธ๋ฆด ์ ์๋ค.
๊ฑฐ๋ถ์ด๋ ์์น์ ๊ฐ๋๋ก ํํํ ์ ์๋ค. ๊ฑฐ๋ถ์ด๋ ์ ์ ์ฐํ์ ๋ฌผ๊ณ ์๋๋ฐ, ์ฐํ์ ๋ด๋ฆฌ๋ฉด ์์ง์ผ ๋ ํ๋ฉด์ ์ ์ ๊ทธ๋ฆฌ๊ณ , ์ฌ๋ฆฌ๋ฉด ์ ์ ๊ทธ๋ฆฌ์ง ์๊ณ ๊ทธ๋ฅ ์ง๋๊ฐ๊ธฐ๋ง ํ๋ค.
์ ์ผ ์ฒ์์ ๊ฑฐ๋ถ์ด๋ (0,0)์ ์๊ณ , ๊ฑฐ๋ถ์ด๊ฐ ๋ณด๊ณ ์๋ ๋ฐฉํฅ์ y์ถ์ด ์ฆ๊ฐํ๋ ๋ฐฉํฅ์ด๋ค. ๋ํ ์ฐํ์ ๋ด๋ฆฌ๊ณ ์๋ค.
์ฌ์ฉ์๋ ๋ค์๊ณผ ๊ฐ์ ๋ค์ฏ๊ฐ์ง ๋ช ๋ น์ผ๋ก ๊ฑฐ๋ถ์ด๋ฅผ ์กฐ์ ํ ์ ์๋ค.
- FD x: ๊ฑฐ๋ถ์ด๋ฅผ x๋งํผ ์์ผ๋ก ์ ์ง
- LT a: ๊ฑฐ๋ถ์ด๋ฅผ ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก a๋ ๋งํผ ํ์
- RT a: ๊ฑฐ๋ถ์ด๋ฅผ ์๊ณ ๋ฐฉํฅ์ผ๋ก a๋ ๋งํผ ํ์
- PU: ์ฐํ์ ์ฌ๋ฆฐ๋ค
- PD: ์ฐํ์ ๋ด๋ฆฐ๋ค.
์ถ์ ํํํ ์ง์ฌ๊ฐํ N๊ฐ๊ฐ ์ฃผ์ด์ก์ ๋, ์ด ์ง์ฌ๊ฐํ์ ๊ทธ๋ฆฌ๋๋ฐ ํ์ํ PU ๋ช ๋ น์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๊ฑฐ๋ถ์ด๋ ๊ฐ์ ์ ์ ์ฌ๋ฌ ๋ฒ ๊ทธ๋ฆด ์ ์์ง๋ง, ๋ฌธ์ ์ ์ฃผ์ด์ง ์ง์ฌ๊ฐํ N๊ฐ๋ฅผ ์ ์ธํ ์ด๋ค ๊ฒ๋ ๊ทธ๋ฆด ์ ์๋ค. ๊ฑฐ๋ถ์ด์ ํฌ๊ธฐ๋ ์์ฃผ ์์์ ์ขํ ํ๋ฉด์ ํ ์ ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค. ์ง์ฌ๊ฐํ์ ๋ณ์ ์ถ์ ํํํ๋ค.
ํ์ด
- ์ฒ์์ ๋ฐ์ ์ฌ๊ฐํ ๋ชจ๋ 1๋ก ์น ํ๊ธฐ
- dfs ๋๋ฉด์ ๊ฐ์ด 1์ด๋ฉด 2๋ก ๋ง๋๋ ์ฝ๋ ์คํ
- ์ขํ์์ผ๋ก๋ -500๊น์ง ์ด๋ํ ์ ์์ผ๋ฏ๋ก ๋ฐฐ์ด๋ก ํํํ๊ธฐ ์ํด 500์ ๋ํด์ค์ผ ํจ
- dfs ๋๋ ค๋ฉด ๋ฐ๋ก ์์ ์๋ ์ ์ผ๋ก ์ด๋ํ์ง ์๊ธฐ ์ํด ์์น์ ๊ณฑํ๊ธฐ 2ํด์ฃผ์ด์ผ ํจ
- ๊ฐ์ด 0์ด๊ฑฐ๋ 2๋ฉด (์ฌ๊ฐํ์ด ์๋๊ฑฐ๋, ๋ค๋ฅธ ์ฌ๊ฐํ์ด๋ฉด) ๊ฑด๋๋ฐ๊ธฐ
- ํ ๋ฒ loop ๋ ๋๋ง๋ค ํ ๋ถ์ผ๋ก ๊ทธ๋ฆฐ๋ค๊ณ ์๊ฐํ์ฌ result ๋๋ ค์ฃผ๊ธฐ
- (0, 0)์์ ์ฐํ์ ๋ด๋ฆฌ๊ณ ์์ผ๋ฏ๋ก (0, 0)์ ๋ค๋ฅธ ์ ์ด ์์ผ๋ฉด result-1 ํ์
์ฝ๋
#include <iostream>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <unordered_set>
using namespace std;
int N;
int map[2001][2001];
int groupNum = 0;
int result = 0;
int direction[4][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };
void checkMap(int minX, int maxX, int minY, int maxY, int group) { // O(n)
// ์ฌ๊ฐํ ๋๋ ์ฒดํฌํ๋ ํจ์
for (int j = minY; j <= maxY; j++) {
map[maxX][j] = group;
map[minX][j] = group;
}
for (int i = minX; i <= maxX; i++) {
map[i][minY] = group;
map[i][maxY] = group;
}
}
void visitMap(int r, int c) { // dfs
if (map[r][c] == 0 || map[r][c] == 2) return; // ์ ๋ค๋ฌ๋ ๋๊ฑฐ๋ ์ด๋ฏธ ๋ค๋ ์ผ๋ฉด ํจ์ค
map[r][c] = 2;
for (int i = 0; i < 4; i++) {
int newR = direction[i][0] + r;
int newC = direction[i][1] + c;
if (newR < 0 || newC < 0 || newR > 2000 || newC > 2000) continue;
visitMap(newR, newC);
}
}
int main() {
cin >> N;
fill(&map[0][0], &map[2000][2001], 0);
for (int i = 0; i < N; i++) { // O(n^2)
int x, y, x2, y2;
cin >> x >> y >> x2 >> y2;
checkMap((x + 500) * 2, (x2 + 500) * 2, (y + 500) * 2, (y2 + 500) * 2, 1); // *2 + 500
}
for (int i = 0; i < 2001; i++) {
for (int j = 0; j < 2001; j++) { // 10^6
if (map[i][j] == 1) {
visitMap(i, j);
result++;
}
}
}
if (map[1000][1000] != 0) { // (0, 0)์์ ์์ํ๋๊ฒ ์์ผ๋ฉด -1
result--;
}
cout << result;
cin >> N;
}
๊ฒฐ๊ณผ
๋ฌธ์ | ๋ฉ๋ชจ๋ฆฌ | ์๊ฐ | ์ฝ๋ ๊ธธ์ด |
---|---|---|---|
gmldms784 | 19280 | 20 | 1422 |
'Algorithm ๋ฌธ์ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[c++] BOJ 5430 :: AC (0) | 2021.09.07 |
---|---|
[c++] BOJ 14725 :: ๊ฐ๋ฏธ๊ตด (0) | 2021.09.07 |
[c++] BOJ 1027 :: ๊ณ ์ธต ๊ฑด๋ฌผ (0) | 2021.08.31 |
[c++] BOJ 17370 :: ์ก๊ฐํ ์ฐ๋ฆฌ ์์ ๊ฐ๋ฏธ (0) | 2021.08.24 |
[c++] BOJ 1941 :: ์๋ฌธ๋ ์น ๊ณต์ฃผ (0) | 2021.08.24 |
Comment