๋ฐฑ์ค 14503๋ฒ : ๋ก๋ด์ฒญ์๊ธฐ with C++
๋ฌธ์
๋ก๋ด ์ฒญ์๊ธฐ์ ๋ฐฉ์ ์ํ๊ฐ ์ฃผ์ด์ก์ ๋, ์ฒญ์ํ๋ ์์ญ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋ ๋ฐฉ์ N x M ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ผ๋ก ๋ํ๋ผ ์ ์์ผ๋ฉฐ, 1×1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ์นธ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ๊ฐ๊ฐ์ ์นธ์ ๋ฒฝ ๋๋ ๋น ์นธ์ด๋ค. ์ฒญ์๊ธฐ๋ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ด ์์ผ๋ฉฐ, ์ด ๋ฐฉํฅ์ ๋, ์, ๋จ, ๋ถ ์ค ํ๋์ด๋ค. ๋ฐฉ์ ๊ฐ ์นธ์ ์ขํ (r, c)๋ก ๋ํ๋ผ ์ ์๊ณ , ๊ฐ์ฅ ๋ถ์ชฝ ์ค์ ๊ฐ์ฅ ์์ชฝ ์นธ์ ์ขํ๊ฐ (0,0) ๊ฐ์ฅ ๋จ์ชฝ ์ค์ ๊ฐ์ฅ ๋์ชฝ ์นธ์ ์ขํ๊ฐ ์ด๋ค. ์ฆ, ์ขํ ๋ ๋ถ์ชฝ์์ ๋ฒ์งธ์ ์๋ ์ค์ ์์ชฝ์์ ๋ฒ์งธ ์นธ์ ๊ฐ๋ฆฌํจ๋ค. ์ฒ์์ ๋น ์นธ์ ์ ๋ถ ์ฒญ์๋์ง ์์ ์ํ์ด๋ค.
๋ก๋ด ์ฒญ์๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ด ์๋ํ๋ค.
- ํ์ฌ ์นธ์ด ์์ง ์ฒญ์๋์ง ์์ ๊ฒฝ์ฐ, ํ์ฌ ์นธ์ ์ฒญ์ํ๋ค.
- ํ์ฌ ์นธ์ ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น ์นธ์ด ์๋ ๊ฒฝ์ฐ,
- ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ์ ์งํ ์ฑ๋ก ํ ์นธ ํ์งํ ์ ์๋ค๋ฉด ํ ์นธ ํ์งํ๊ณ 1๋ฒ์ผ๋ก ๋์๊ฐ๋ค.
- ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ๋ค์ชฝ ์นธ์ด ๋ฒฝ์ด๋ผ ํ์งํ ์ ์๋ค๋ฉด ์๋์ ๋ฉ์ถ๋ค.
- ํ์ฌ ์นธ์ ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น ์นธ์ด ์๋ ๊ฒฝ์ฐ,
- ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก 90๋ ํ์ ํ๋ค.
- ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ๊ธฐ์ค์ผ๋ก ์์ชฝ ์นธ์ด ์ฒญ์๋์ง ์์ ๋น ์นธ์ธ ๊ฒฝ์ฐ ํ ์นธ ์ ์งํ๋ค.
- 1๋ฒ์ผ๋ก ๋์๊ฐ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฐฉ์ ํฌ๊ธฐ N๊ณผ M์ด ์ ๋ ฅ๋๋ค. (3≤N,M≤50)โ ๋์งธ ์ค์ ์ฒ์์ ๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋ ์นธ์ ์ขํ ์ ์ฒ์์ ๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ d๊ฐ ์ ๋ ฅ๋๋ค. ๊ฐ 0์ธ ๊ฒฝ์ฐ ๋ถ์ชฝ, 1์ธ ๊ฒฝ์ฐ ๋์ชฝ, 2์ธ ๊ฒฝ์ฐ ๋จ์ชฝ, 3์ธ ๊ฒฝ์ฐ ์์ชฝ์ ๋ฐ๋ผ๋ณด๊ณ ์๋ ๊ฒ์ด๋ค.
์ ์งธ ์ค๋ถํฐ ๊ฐ์ ์ค์ ๊ฐ ์ฅ์์ ์ํ๋ฅผ ๋ํ๋ด๋ ๊ฐ์ ๊ฐ์ด ํ ์ค์ ๊ฐ์ฉ ์ ๋ ฅ๋๋ค. ๋ฒ์งธ ์ค์ ๋ฒ์งธ ๊ฐ์ ์นธ ์ ์ํ๋ฅผ ๋ํ๋ด๋ฉฐ, ์ด ๊ฐ์ด 0์ธ ๊ฒฝ์ฐ ๊ฐ ์ฒญ์๋์ง ์์ ๋น ์นธ์ด๊ณ , 1์ธ ๊ฒฝ์ฐ ์ ๋ฒฝ์ด ์๋ ๊ฒ์ด๋ค. ๋ฐฉ์ ๊ฐ์ฅ ๋ถ์ชฝ, ๊ฐ์ฅ ๋จ์ชฝ, ๊ฐ์ฅ ์์ชฝ, ๊ฐ์ฅ ๋์ชฝ ์ค ์ค ํ๋ ์ด์์ ์์นํ ๋ชจ๋ ์นธ์๋ ๋ฒฝ์ด ์๋ค. ๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋ ์นธ์ ํญ์ ๋น ์นธ์ด๋ค.
์ถ๋ ฅ
๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋์ ์์ํ ํ ์๋์ ๋ฉ์ถ ๋๊น์ง ์ฒญ์ํ๋ ์นธ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
** ๊ตฌํ ๋ฐฉ๋ฒ์ ์ฝ๋์ ์ฃผ์์ ํตํด ํ์ธํ ์ ์๋ค.
๊ตฌํ ์๊ฐ
0ms
#include <iostream>
using namespace std;
int main()
{
int N, M;
int row, clm; // ํ์ฌ ํ/์ด ์์น
int dir; // 0: ์(๋ถ์ชฝ), 1: ์ฐ(๋์ชฝ), 2: ์๋(๋จ์ชฝ), 3: ์ข(์์ชฝ)
int dx[] = {0, 1, 0, -1};
int dy[] = {-1, 0, 1, 0};
int room[51][51]; // 0: ์ฒญ์X, 1: ๋ฒฝ, 2: ์ฒญ์O
int clean = 0;
cin >> N >> M;
cin >> row >> clm >> dir;
for (int n = 0; n < N; n++) {
for (int m = 0; m < M; m++) {
cin >> room[n][m];
}
}
while (1) {
if (room[row][clm] == 0) { // ํ์ฌ ์นธ ์ฒญ์ ์๋ ๊ฒฝ์ฐ ์ฒญ์
room[row][clm] = 2;
clean++;
}
else{
int i;
for (i = 0; i < 4; i++) { // ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น์นธ ํ์ธ
if (room[row + dy[(dir + i) % 4]][clm + dx[(dir + i) % 4]] == 0) {
break;
}
}
if (i == 4) { // ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น์นธ์ด ์๋ ๊ฒฝ์ฐ ๋ค๋ก ์ด๋
row -= dy[dir];
clm -= dx[dir];
if (room[row][clm] == 1) { // ๋์ด์ ๋ค๋ก ๊ฐ๋ฐ ์์ผ๋ฉด ๋
break;
}
}
else { // ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น์นธ์ด ์๋ ๊ฒฝ์ฐ
do {
dir = (dir + 3) % 4; // ๋ฐ์๊ณ ๋ฐฉํฅ 90๋ ํ์
} while (room[row + dy[dir]][clm + dx[dir]] != 0);
row += dy[dir];
clm += dx[dir];
room[row][clm] = 2;
clean++;
}
}
}
cout << clean;
return 0;
}