๋ฌธ์
๋๋๊ณค ์ปค๋ธ๋ ๋ค์๊ณผ ๊ฐ์ ์ธ ๊ฐ์ง ์์ฑ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ผ๋ฉฐ, ์ด์ฐจ์ ์ขํ ํ๋ฉด ์์์ ์ ์๋๋ค. ์ขํ ํ๋ฉด์ x์ถ์ → ๋ฐฉํฅ, y์ถ์ ↓ ๋ฐฉํฅ์ด๋ค.
- ์์ ์
- ์์ ๋ฐฉํฅ
- ์ธ๋
0์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ๊ธธ์ด๊ฐ 1์ธ ์ ๋ถ์ด๋ค. ์๋ ๊ทธ๋ฆผ์ (0, 0)์์ ์์ํ๊ณ , ์์ ๋ฐฉํฅ์ ์ค๋ฅธ์ชฝ์ธ 0์ธ๋ ๋๋๊ณค ์ปค๋ธ์ด๋ค.
1์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ 0์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ฅผ ๋ ์ ์ ๊ธฐ์ค์ผ๋ก ์๊ณ ๋ฐฉํฅ์ผ๋ก 90๋ ํ์ ์ํจ ๋ค์ 0์ธ๋ ๋๋๊ณค ์ปค๋ธ์ ๋ ์ ์ ๋ถ์ธ ๊ฒ์ด๋ค. ๋ ์ ์ด๋ ์์ ์ ์์ ์ ๋ถ์ ํ๊ณ ์ด๋ํ์ ๋, ๊ฐ์ฅ ๋จผ ๊ฑฐ๋ฆฌ์ ์๋ ์ ์ ์๋ฏธํ๋ค.
2์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ 1์ธ๋๋ฅผ ๋ง๋ ๋ฐฉ๋ฒ์ ์ด์ฉํด์ ๋ง๋ค ์ ์๋ค. (ํ๋์ ์ ๋ถ์ ์๋ก ์ถ๊ฐ๋ ์ ๋ถ์ ๋ํ๋ธ๋ค)
3์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ 2์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ฅผ ์ด์ฉํด ๋ง๋ค ์ ์๋ค. ์๋ ๊ทธ๋ฆผ์ 3์ธ๋ ๋๋๊ณค ์ปค๋ธ์ด๋ค.
์ฆ, K(K > 1)์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ K-1์ธ๋ ๋๋๊ณค ์ปค๋ธ๋ฅผ ๋ ์ ์ ๊ธฐ์ค์ผ๋ก 90๋ ์๊ณ ๋ฐฉํฅ ํ์ ์ํจ ๋ค์, ๊ทธ๊ฒ์ ๋ ์ ์ ๋ถ์ธ ๊ฒ์ด๋ค.
ํฌ๊ธฐ๊ฐ 100×100์ธ ๊ฒฉ์ ์์ ๋๋๊ณค ์ปค๋ธ๊ฐ N๊ฐ ์๋ค. ์ด๋, ํฌ๊ธฐ๊ฐ 1×1์ธ ์ ์ฌ๊ฐํ์ ๋ค ๊ผญ์ง์ ์ด ๋ชจ๋ ๋๋๊ณค ์ปค๋ธ์ ์ผ๋ถ์ธ ์ ์ฌ๊ฐํ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๊ฒฉ์์ ์ขํ๋ (x, y)๋ก ๋ํ๋ด๋ฉฐ, 0 ≤ x ≤ 100, 0 ≤ y ≤ 100๋ง ์ ํจํ ์ขํ์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋๋๊ณค ์ปค๋ธ์ ๊ฐ์ N(1 ≤ N ≤ 20)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๋๋๊ณค ์ปค๋ธ์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. ๋๋๊ณค ์ปค๋ธ์ ์ ๋ณด๋ ๋ค ์ ์ x, y, d, g๋ก ์ด๋ฃจ์ด์ ธ ์๋ค. x์ y๋ ๋๋๊ณค ์ปค๋ธ์ ์์ ์ , d๋ ์์ ๋ฐฉํฅ, g๋ ์ธ๋์ด๋ค. (0 ≤ x, y ≤ 100, 0 ≤ d ≤ 3, 0 ≤ g ≤ 10)
์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ๋๋๊ณค ์ปค๋ธ๋ ๊ฒฉ์ ๋ฐ์ผ๋ก ๋ฒ์ด๋์ง ์๋๋ค. ๋๋๊ณค ์ปค๋ธ๋ ์๋ก ๊ฒน์น ์ ์๋ค.
๋ฐฉํฅ์ 0, 1, 2, 3 ์ค ํ๋์ด๊ณ , ๋ค์์ ์๋ฏธํ๋ค.
- 0: x์ขํ๊ฐ ์ฆ๊ฐํ๋ ๋ฐฉํฅ (→)
- 1: y์ขํ๊ฐ ๊ฐ์ํ๋ ๋ฐฉํฅ (↑)
- 2: x์ขํ๊ฐ ๊ฐ์ํ๋ ๋ฐฉํฅ (←)
- 3: y์ขํ๊ฐ ์ฆ๊ฐํ๋ ๋ฐฉํฅ (↓)
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ํฌ๊ธฐ๊ฐ 1×1์ธ ์ ์ฌ๊ฐํ์ ๋ค ๊ผญ์ง์ ์ด ๋ชจ๋ ๋๋๊ณค ์ปค๋ธ์ ์ผ๋ถ์ธ ๊ฒ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
https://www.acmicpc.net/problem/15685
๐ก ํ์ด ๋ฐ ์ฝ๋
n = int(input())
data = []
grid = [[0] * 101 for _ in range(101)]
for _ in range(n):
data.append(tuple(map(int, input().split())))
dx, dy = [0, -1, 0, 1], [1, 0, -1, 0]
for y, x, d, g in data:
dragon = []
dragon.append((x, y, d))
grid[x][y] = 1
nx, ny = x + dx[d], y + dy[d]
for _ in range(g):
length = len(dragon)
for i in range(length-1, -1, -1):
d = (dragon[i][2] + 1) % 4
dragon.append((nx, ny, d))
grid[nx][ny] = 1
nx, ny = nx + dx[d], ny + dy[d]
grid[nx][ny] = 1
result = 0
for i in range(100):
for j in range(100):
if grid[i][j] and grid[i+1][j] and grid[i][j+1] and grid[i+1][j+1]:
result += 1
print(result)
dragon ์ด๋ผ๋ ๋ฐฐ์ด์ ๊ทธ๋ฆด ๊ฒฝ๋ก์ ์์ ์์น(x, y)์ ๋ฐฉํฅ(d)๋ฅผ ์ ์ฅํ๊ณ , ํด๋น ๋์ (nx, ny)๋ฅผ ๊ธฐ์ค์ผ๋ก 90๋ ์๊ณ ๋ฐฉํฅ์ผ๋ก ๋ฐฉํฅ ๋๋ ค๊ฐ๋ฉฐ ํ๋ํ๋ ๊ทธ๋ ค๋๊ฐ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค. ์ด๋, ์ด์ ๊ฒฝ๋ก์ ๋์ ์ ๊ธฐ์ค์ผ๋ก ๊ทธ๋ ค๋๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ dragon ๋ฐฐ์ด์ ์ญ์ํํ๋ฉด์ ์ ์ฅ๋์ด์๋ ๋ฐฉํฅ์ 90๋ ๊บพ์ ๋ฐฉํฅ(d = (dragon[i][2] + 1) % 4)์ผ๋ก ์ด์ ๊ฒฝ๋ก์ ๋์ ์ ์ฐ๊ฒฐํด์ผ ํ๋ค.
'Algorithm > ๐ Baekjoon Judge' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[BOJ] ๋ฐฑ์ค 21608๋ฒ ์์ด ์ด๋ฑํ๊ต - ํ์ด์ฌ(Python) (0) | 2022.10.07 |
---|---|
[BOJ] ๋ฐฑ์ค 17144๋ฒ ๋ฏธ์ธ๋จผ์ง ์๋ ! - ํ์ด์ฌ(Python) (0) | 2022.08.26 |
[BOJ] ๋ฐฑ์ค 2133๋ฒ ํ์ผ ์ฑ์ฐ๊ธฐ - ํ์ด์ฌ(Python) (0) | 2022.08.18 |
[BOJ] ๋ฐฑ์ค 2294๋ฒ ๋์ 2 - ํ์ด์ฌ(Python) (0) | 2022.08.18 |
[BOJ] ๋ฐฑ์ค 1890๋ฒ ์ ํ - ํ์ด์ฌ(Python) (0) | 2022.08.13 |