๐ข ๋ก๋ด์ฒญ์๊ธฐ
1. ๋ฌธ์ ๋งํฌ
2. ์ฝ๋
Python3
30840KB
72ms
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
"""
[1091] ์นด๋ ์๊ธฐ
๐ ๋ฌธ์
๋ก๋ด ์ฒญ์๊ธฐ์ ๋ฐฉ์ ์ํ๊ฐ ์ฃผ์ด์ก์ ๋, ์ฒญ์ํ๋ ์์ญ์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋ ๋ฐฉ์ N X N ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ผ๋ก ๋ํ๋ผ ์ ์์ผ๋ฉฐ,
1 X 1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ์นธ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ๊ฐ๊ฐ์ ์นธ์ ๋ฒฝ ๋๋ ๋น ์นธ์ด๋ค.
์ฒญ์๊ธฐ๋ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ด ์์ผ๋ฉฐ, ์ด ๋ฐฉํฅ์ ๋, ์, ๋จ, ๋ถ ์ค ํ๋์ด๋ค.
๋ฐฉ์ ๊ฐ ์นธ์ ์ขํ (r, c)๋ก ๋ํ๋ผ ์ ์๊ณ , ๊ฐ์ฅ ๋ถ์ชฝ ์ค์ ๊ฐ์ฅ ์์ชฝ ์นธ์ ์ขํ๊ฐ (0, 0), ๊ฐ์ฅ ๋จ์ชฝ ์ค์ ๊ฐ์ฅ ๋์ชฝ ์นธ์ ์ขํ๊ฐ (N-1, M-1)
์ขํ (r, c)๋ ๋ถ์ชฝ์์ (r+1)๋ฒ์งธ์ ์๋ ์ค์ ์์ชฝ์์ (c+1)๋ฒ์งธ ์นธ์ ๊ฐ๋ฆฌํจ๋ค. ์ฒ์์ ๋น ์นธ์ ์ ๋ถ ์ฒญ์๋์ง ์์ ์ํ์ด๋ค.
๋ก๋ด ์ฒญ์๊ธฐ๋ ๋ค์๊ณผ ๊ฐ์ด ์๋ํ๋ค.
1 ํ์ฌ ์นธ์ด ์์ง ์ฒญ์๋์ง ์์ ๊ฒฝ์ฐ, ํ์ฌ ์นธ์ ์ฒญ์ํ๋ค.
2. ํ์ฌ ์นธ์ ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น ์นธ์ด ์๋ ๊ฒฝ์ฐ,
- ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ์ ์งํ ์ฑ๋ก ํ ์นธ ํ์งํ ์ ์๋ค๋ฉด ํ ์นธ ํ์งํ๊ณ 1๋ฒ์ผ๋ก ๋์๊ฐ๋ค.
- ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ๋ค์ชฝ ์นธ์ด ๋ฒฝ์ด๋ผ ํ์งํ ์ ์๋ค๋ฉด ์๋์ ๋ฉ์ถ๋ค.
3. ํ์ฌ ์นธ์ ์ฃผ๋ณ 4์นธ ์ค ์ฒญ์๋์ง ์์ ๋น ์นธ์ด ์๋ ๊ฒฝ์ฐ,
- ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก 90๋ ํ์ ํ๋ค.
- ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ๊ธฐ์ค์ผ๋ก ์์ชฝ ์นธ์ด ์ฒญ์๋์ง ์์ ๋น ์นธ์ธ ๊ฒฝ์ฐ ํ ์นธ ์ ์งํ๋ค.
- 1๋ฒ์ผ๋ก ๋์๊ฐ๋ค.
๐ ์
๋ ฅ
์ฒซ์งธ ์ค์ ๋ฐฉ์ ํฌ๊ธฐ N๊ณผ M์ด ์
๋ ฅ๋๋ค. (3 <= N, M <= 50)
๋์งธ ์ค์ ์ฒ์์ ๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋ ์นธ์ ์ขํ (r, c)์ ์ฒ์์ ๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ d๊ฐ ์
๋ ฅ๋๋ค.
d๊ฐ 0์ธ ๊ฒฝ์ฐ ๋ถ์ชฝ, 1์ธ ๊ฒฝ์ฐ ๋์ชฝ, 2์ธ ๊ฒฝ์ฐ ๋จ์ชฝ, 3์ธ ๊ฒฝ์ฐ ์์ชฝ์ ๋ฐ๋ผ๋ณด๊ณ ์๋ ๊ฒ์ด๋ค.
์
์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฐ ์ฅ์์ ์ํ๋ฅผ ๋ํ๋ด๋ N X M๊ฐ์ ๊ฐ์ด ํ ์ค์ M๊ฐ์ฉ ์
๋ ฅ๋๋ค.
i๋ฒ์งธ ์ค์ j๋ฒ์งธ ๊ฐ์ ์นธ (i, j)์ ์ํ๋ฅผ ๋ํ๋ด๋ฉฐ, ์ด ๊ฐ์ด 0์ธ ๊ฒฝ์ฐ (i, j)๊ฐ ์ฒญ์๋์ง ์์ ๋น ์นธ์ด๊ณ ,
1์ธ ๊ฒฝ์ฐ (i, j)์ ๋ฒฝ์ด ์๋ ๊ฒ์ด๋ค. ๋ฐฉ์ ๊ฐ์ฅ ๋ถ์ชฝ, ๊ฐ์ฅ ๋จ์ชฝ, ๊ฐ์ฅ ์์ชฝ, ๊ฐ์ฅ ๋์ชฝ ์ค ์ค ํ๋ ์ด์์ ์์นํ ๋ชจ๋ ์นธ์๋ ๋ฒฝ์ด ์๋ค.
๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋ ์นธ์ ํญ์ ๋น ์นธ์ด๋ค.
๐ ์ถ๋ ฅ
๋ก๋ด ์ฒญ์๊ธฐ๊ฐ ์๋์ ์์ํ ํ ์๋์ ๋ฉ์ถ ๋๊น์ง ์ฒญ์ํ๋ ์นธ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
"""
# ๋ฐฉ์ ํฌ๊ธฐ N๊ณผ M
N, M = map(int, input().split())
# ์ขํ์ ๋ฐฉํฅ (0 ๋ถ, 1 ๋, 2 ๋จ, 3 ์)
R, C, D = map(int, input().split())
graph = []
for i in range(N):
graph.append(list(map(int, input().split())))
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
def turn():
global D
# ์ขํ์ ๋ฐฉํฅ (0 ๋ถ, 1 ๋, 2 ๋จ, 3 ์)
D = (D - 1) % 4
count = 1
# ์ฒญ์๊ธฐ ์์น
graph[R][C] = 2
while True:
check = False
for i in range(4):
turn()
nx = R + dx[D]
ny = C + dy[D]
if 0 <= nx < N and 0 <= ny < M:
if graph[nx][ny] == 0:
count += 1
graph[nx][ny] = 2
R, C = nx, ny
# ๋ฐฉ๋ฌธ์ผ๋ก check
check = True
break
# ํ์งํ๊ธฐ
if not check:
nx = R - dx[D]
ny = C - dy[D]
if 0 <= nx < N and 0 <= ny < M:
if graph[nx][ny] == 2: # ์ด๋ฏธ ๋ฐฉ๋ฌธ
R, C = nx, ny
elif graph[nx][ny] == 1: # ๋ฒฝ
print(count)
break
else:
print(count)
break
3. ํด์ค
global D ๋ฅผ ํตํด ๋ฐฉํฅ์ ์ ์ํจ
This post is licensed under CC BY 4.0 by the author.