๊ฐ๋จํ ๋ฌธ์ ์ค๋ช
๊ฒ์ ์บ๋ฆญํฐ๊ฐ ๋งต ์์์ ์์ง์ธ๋ค.
1 x 1 ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ๋ค์ด, n x m ํฌ๊ธฐ์ ์ง์ฌ๊ฐํ์ผ๋ก ์ด๋ค์ ธ์๋ค.
๊ฐ๊ฐ์ ์นธ์ ์ก์ง ๋๋ ๋ฐ๋ค์ด๋ค.
์บ๋ฆญํฐ๋ ๋์๋จ๋ถ ์ค ํ ๊ณณ์ ๋ฐ๋ผ๋ณธ๋ค.
๋งต์ ๊ฐ ์นธ์ (A, B) ๋ก ๋ํ๋ธ๋ค.
A๋ ๋ถ์ชฝ์ผ๋ก ๋จ์ด์ง ์นธ์ ๊ฐ์์ด๋ค.
B๋ ์์ชฝ์ผ๋ก ๋จ์ด์ง ์นธ์ ๊ฐ์์ด๋ค.
์บ๋ฆญํฐ๋ ์ํ์ข์ฐ๋ก ์์ง์ธ๋ค.
๋ฐ๋ค๋ก ๋์ด ์๋ ๊ณต๊ฐ์ ๊ฐ ์ ์๋ค.
์บ๋ฆญํฐ ์์ง์์ ์ค์ ํ๊ธฐ ์ํด ์ ํด ๋์ ๋ฉ๋ด์ผ์ ์ด๋ ๋ค.
- ํ์์น์์ ํ์ฌ ๋ฐฉํฅ์ ๊ธฐ์ค, ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก๋ถํฐ ์ฐจ๋ก๋๋ก ๊ฐ ๊ณณ์ ์ ํ๋ค. ( ๋ฐ์๊ณ ๋ฐฉํฅ์ผ๋ก 90๋ ํ์ ํ ๋ฐฉํฅ)
- ์บ๋ฆญํฐ์ ๋ฐ๋ก ์ผ์ชฝ ๋ฐฉํฅ์ ์์ง ๊ฐ๋ณด์ง ์์ ์นธ์ด ์กด์ฌ์, ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ํ์ ํ ๋ค์ ์ผ์ชฝ์ผ๋ก ํ ์นธ์ ์ ์ง, ์ผ์ชฝ ๋ฐฉํฅ์ ๊ฐ๋ณด์ง ์์ ์นธ์ด ์์ผ๋ฉด, ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ํ์ ๋ง ์ํํ๊ณ 1๋จ๊ณ๋ก ๋์์จ๋ค.
- ๋ง์ฝ ๋ค ๋ฐฉํฅ ๋ชจ๋ ์ด๋ฏธ ๊ฐ๋ณธ ์นธ์ด๊ฑฐ๋ ๋ฐ๋ค๋ก ๋์ด ์๋ ๊ฒฝ์ฐ, ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ์ ์ ์งํ๊ณ ํ ์นธ ๋ค๋ก ๊ฐ๊ณ 1๋จ๊ณ๋ก ๋์๊ฐ๋ค. ๋จ, ์ด๋ ๋ค์ชฝ ๋ฐฉํฅ์ด ๋ฐ๋ค์ธ ์นธ์ด๋ผ ๋ค๋ก ๊ฐ ์ ์๋ ๊ฒฝ์ฐ์๋ ์์ง์์ ๋ฉ์ถ๋ค.
์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด์ ์บ๋ฆญํฐ ์์ง์์ ์ด์์ด ์๋์ง๋ฅผ ํ ์คํธํ๋ค.
๋ฉ๋ด์ผ์ ๋ฐ๋ผ ์บ๋ฆญํฐ๋ฅผ ์ด๋์ํค๊ณ , ์บ๋ฆญํฐ๊ฐ ๋ฐฉ๋ฌธํ ์นธ์ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋์์ค.
์ ๋ ฅ์กฐ๊ฑด
์ฒซ์งธ ์ค์ ๋งต์ ์ธ๋ก ํฌ๊ธฐ N ๊ณผ ๊ฐ๋ก ํฌ๊ธฐ M์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ ๋ ฅ
(3 <= N, M <= 50)
๋์งธ ์ค์ ๊ฒ์ ์บ๋ฆญํฐ๊ฐ ์๋ ์นธ์ ์ขํ (A, B) ์ ๋ฐ๋ผ๋ณด๋ ๋ฐฉํฅ d ๊ฐ ์๋ก ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ฃผ์ด์ง๋ค. ๋ฐฉํฅ d์ ๊ฐ์ผ๋ก๋ 4๊ฐ์ง๊ฐ ์กด์ฌํ๋ค.
_ _ _ <<
0 : ๋ถ์ชฝ
1 : ๋์ชฝ
2 : ๋จ์ชฝ
3 : ์์ชฝ
์ ์งธ ์ฃผ์๋ ๋งต์ด ์ก์ง์ธ์ง ๋ฐ๋ค์ธ์ง์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค. N๊ฐ์ ์ค์ ๋งต์ ์ํ๊ฐ ๋ถ์ชฝ๋ถํฐ ๋จ์ชฝ ์์๋๋ก, ๊ฐ ์ค์ ๋ฐ์ดํฐ๋ ์์ชฝ๋ถํฐ ๋์ชฝ ์์๋๋ก ์ฃผ์ด์ง๋ค. ๋งต์ ์ธ๊ณฝ์ ํญ์ ๋ฐ๋ค๋ก ๋์ด ์๋ค.
0 : ์ก์ง
1 : ๋ฐ๋ค
์ฒ์์ ๊ฒ์ ์บ๋ฆญํฐ๊ฐ ์์นํ ์นธ์ ์ํ๋ ํญ์ ์ก์ง์ด๋ค.
์ถ๋ ฅ ์กฐ๊ฑด
์ฒซ์งธ ์ค์ ์ด๋์ ๋ง์น ํ ์บ๋ฆญํฐ๊ฐ ๋ฐฉ๋ฌธํ ์นธ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ ์์
4 4
1 1 0
1 1 1 1
1 0 0 1
1 1 0 1
1 1 1 1 #
debug..์๋ฌ ๋ฐ์
# n, m ์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์
๋ ฅ๋ฐ๊ธฐ
n, m = map(int, input().split())
# ๋ฐฉ๋ฌธํ ์์น๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ๋งต์ ์์ฑํ์ฌ 0์ผ๋ก ์ด๊ธฐํ
d = [[0] * m for _ in range(n)]
# ํ์ฌ ์บ๋ฆญํฐ์ x์ขํ, y์ขํ, ๋ฐฉํฅ์ ์
๋ ฅ๋ฐ๊ธฐ
x, y, direction = map(int, input().split())
d[x][y] = 1 # ํ์ฌ ์ขํ ๋ฐฉ๋ฌธ ์ฒ๋ฆฌ
# ์ ์ฒด ๋งต ์ ๋ณด๋ฅผ ์
๋ ฅ๋ฐ๊ธฐ
array = []
for i in range(n):
array.append(list(map(int, input().split())))
# ๋ถ,๋,๋จ,์ ๋ฐฉํฅ ์ ์
dx = [-1, 0, 1, 0]
dy = [0, 1, 0, -1]
# ์ผ์ชฝ์ผ๋ก ํ์
def turn_left():
global direction
direction -= 1
if direction == -1:
direction = 3
# ์๋ฎฌ๋ ์ด์
์์
count = 1
turn_time = 0
# ์๋ฎฌ๋ ์ด์
์์
count = 1
turn_time = 0
while True:
# ์ผ์ชฝ์ผ๋ก ํ์
turn_left()
nx = x + dx[direction]
ny = y + dy[direction]
# ํ์ ํ ์ดํ ์ ๋ฉด์ ๊ฐ๋ณด์ง ์์ ์นธ์ด ์กด์ฌํ๋ ๊ฒฝ์ฐ ์ด๋
if d[nx][ny] == 0 and array[nx][ny] == 0:
d[nx][ny] == 1
x = nx
y = ny
count += 1
turn_time = 0
continue
# ํ์ ํ ์ดํ ์ ๋ฉด์ ๊ฐ๋ณด์ง ์์ ์นธ์ด ์๊ฑฐ๋ ๋ฐ๋ค์ธ ๊ฒฝ์ฐ
else:
turn_time += 1
# ๋ค ๋ฐฉํฅ ๋ชจ๋ ๊ฐ ์ ์๋ ๊ฒฝ์ฐ
if turn_time == 4:
nx = x - dx[direction]
ny = y - dy[direction]
# ๋ค๋ก ๊ฐ ์ ์๋ค๋ฉด ์ด๋
if array[nx][ny] == 0:
x = nx
y = ny
# ๋ค๊ฐ ๋ฐ๋ค๋ก ๋งํ์๋ ๊ฒฝ์ฐ
else:
break
turn_time = 0
# ์ ๋ต
print(count)
'๐๏ธ์ํํธ์จ์ด > ๐ปpython' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํ์ด์ฌ์์ ์์๋๋ฉด ์ข์ ๊ธฐ๋ฅ๋ค (0) | 2022.06.14 |
---|---|
python - ์๋ฃ๊ตฌ์กฐ ๊ธฐ์ด : DFS/BFS 1ํ (0) | 2022.04.22 |
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 3ํ:์์ค ๋์ดํธ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.04.21 |
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 2ํ:์๊ฐ ์๊ณ ๋ฆฌ์ฆ (0) | 2022.04.20 |
Python ์๊ณ ๋ฆฌ์ฆ - ๊ตฌํ 1ํ:์ํ์ข์ฐ (0) | 2022.04.20 |