๐ค๋ฌธ์ ํด๊ฒฐ
-
G5 | ์๋ฎฌ๋ ์ด์ , BFS
1. ์ฐํฉ์ ์ฐพ๋๋ค.
ํ์ฌ์์น์ ์ธ์ ํ ์์น์ ๊ฐ์ ์ฐจ์ด๊ฐ ์กฐ๊ฑด์ ๋ง์ผ๋ฉด ์ฐํฉ๋ฆฌ์คํธ์ ๋ฃ์ด์คฌ๋ค. (BFS)
2. ๋ง์ฝ ์ฐํฉ์ด ์์ผ๋ฉด ๋
3. ์ฐํฉ์ด ์์ผ๋ฉด ์ฐํฉ ๋ด์์ ์ธ๊ตฌ ์ด๋์ ํ๋ค.
์ฐํฉ์ ๋ชจ๋ ์ธ๊ตฌ์ ํ๊ท ๊ฐ์ผ๋ก ๋ฐ๊ฟ์ค๋ค.
4. (1,2,3)์ ๋ฐ๋ณตํ๋ค.
while๋ฌธ์ผ๋ก 2๋ฒ์ด ๋์ฌ๋๊น์ง ๋๋ฆฐ๋ค.
๐จ ์๊ฐ์ด๊ณผ๊ฐ ๋์ pypy๋ก ๋๋ ธ๋๋ ํต๊ณผ!!! ํ์ด์ฌ์ ํญ์ ๋๋ ค์ ์ด์ ๊ทธ๋ฌ๋ ค๋ ํ๋ค.
์๋๋ฉด ๋ญ๊ฐ ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์๋ ๊ฒ ๊ฐ๋ค. ์ฐพ์๋ณด๋ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ํ์ฉํด์ ํ๋ ๋ฐฉ๋ฒ๋ ์์ง๋ง.... ๋์ค์ ๋์ ํด๋ณด๊ฒ ๋ค.
๐ป์์ค ์ฝ๋
from _collections import deque
def move_population(union_list):
for union in union_list:
total = 0
for country in union:
x, y = country
total += world[x][y]
population = total // len(union)
for country in union:
x, y = country
world[x][y] = population
def find_union(x, y):
q = deque()
q.append((x, y))
union = []
union.append((x, y))
while q:
cx, cy = q.popleft()
for k in range(4):
nx = cx + dx[k]
ny = cy + dy[k]
if 0 <= nx < N and 0 <= ny < N and (nx, ny) not in visited:
if L <= abs(world[cx][cy] - world[nx][ny]) <= R:
union.append((nx, ny))
visited.add((nx, ny))
q.append((nx, ny))
if len(union) > 1:
union_list.append(union)
dx, dy = [-1, 1, 0, 0], [0, 0, -1, 1]
if __name__ == '__main__':
N, L, R = map(int, input().split())
world = [list(map(int, input().split())) for _ in range(N)]
answer = 0
while True:
union_list = []
visited = set()
for i in range(N):
for j in range(N):
if (i, j) not in visited:
visited.add((i, j))
find_union(i, j)
if union_list:
move_population(union_list)
answer += 1
else:
break
print(answer)
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: BACKJOON ONLINE JUDGE
๋งํฌ: https://www.acmicpc.net/problem/16234
๋ฌธ์
N×Nํฌ๊ธฐ์ ๋ ์ด ์๊ณ , ๋ ์ 1×1๊ฐ์ ์นธ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ๊ฐ๊ฐ์ ๋ ์๋ ๋๋ผ๊ฐ ํ๋์ฉ ์กด์ฌํ๋ฉฐ, rํ c์ด์ ์๋ ๋๋ผ์๋ A[r][c]๋ช ์ด ์ด๊ณ ์๋ค. ์ธ์ ํ ๋๋ผ ์ฌ์ด์๋ ๊ตญ๊ฒฝ์ ์ด ์กด์ฌํ๋ค. ๋ชจ๋ ๋๋ผ๋ 1×1 ํฌ๊ธฐ์ด๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ๊ตญ๊ฒฝ์ ์ ์ ์ฌ๊ฐํ ํํ์ด๋ค.
์ค๋๋ถํฐ ์ธ๊ตฌ ์ด๋์ด ์์๋๋ ๋ ์ด๋ค.
์ธ๊ตฌ ์ด๋์ ๋ค์๊ณผ ๊ฐ์ด ์งํ๋๊ณ , ๋ ์ด์ ์๋ ๋ฐฉ๋ฒ์ ์ํด ์ธ๊ตฌ ์ด๋์ด ์์ ๋๊น์ง ์ง์๋๋ค.
- ๊ตญ๊ฒฝ์ ์ ๊ณต์ ํ๋ ๋ ๋๋ผ์ ์ธ๊ตฌ ์ฐจ์ด๊ฐ L๋ช ์ด์, R๋ช ์ดํ๋ผ๋ฉด, ๋ ๋๋ผ๊ฐ ๊ณต์ ํ๋ ๊ตญ๊ฒฝ์ ์ ์ค๋ ํ๋ฃจ๋์ ์ฐ๋ค.
- ์์ ์กฐ๊ฑด์ ์ํด ์ด์ด์ผํ๋ ๊ตญ๊ฒฝ์ ์ด ๋ชจ๋ ์ด๋ ธ๋ค๋ฉด, ์ธ๊ตฌ ์ด๋์ ์์ํ๋ค.
- ๊ตญ๊ฒฝ์ ์ด ์ด๋ ค์์ด ์ธ์ ํ ์นธ๋ง์ ์ด์ฉํด ์ด๋ํ ์ ์์ผ๋ฉด, ๊ทธ ๋๋ผ๋ฅผ ์ค๋ ํ๋ฃจ ๋์์ ์ฐํฉ์ด๋ผ๊ณ ํ๋ค.
- ์ฐํฉ์ ์ด๋ฃจ๊ณ ์๋ ๊ฐ ์นธ์ ์ธ๊ตฌ์๋ (์ฐํฉ์ ์ธ๊ตฌ์) / (์ฐํฉ์ ์ด๋ฃจ๊ณ ์๋ ์นธ์ ๊ฐ์)๊ฐ ๋๋ค. ํธ์์ ์์์ ์ ๋ฒ๋ฆฐ๋ค.
- ์ฐํฉ์ ํด์ฒดํ๊ณ , ๋ชจ๋ ๊ตญ๊ฒฝ์ ์ ๋ซ๋๋ค.
๊ฐ ๋๋ผ์ ์ธ๊ตฌ์๊ฐ ์ฃผ์ด์ก์ ๋, ์ธ๊ตฌ ์ด๋์ด ๋ช ๋ฒ ๋ฐ์ํ๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N, L, R์ด ์ฃผ์ด์ง๋ค. (1 ≤ N ≤ 50, 1 ≤ L ≤ R ≤ 100)
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ ๊ฐ ๋๋ผ์ ์ธ๊ตฌ์๊ฐ ์ฃผ์ด์ง๋ค. rํ c์ด์ ์ฃผ์ด์ง๋ ์ ์๋ A[r][c]์ ๊ฐ์ด๋ค. (0 ≤ A[r][c] ≤ 100)
์ธ๊ตฌ ์ด๋์ด ๋ฐ์ํ๋ ํ์๊ฐ 2,000๋ฒ ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ๋ ฅ๋ง ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ธ๊ตฌ ์ด๋์ด ๋ช ๋ฒ ๋ฐ์ํ๋์ง ์ฒซ์งธ ์ค์ ์ถ๋ ฅํ๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ๋ฐฑ์ค - 7562. ๋์ดํธ์ ์ด๋ (0) | 2020.10.02 |
---|---|
[python] ๋ฐฑ์ค - 4948. ๋ฒ ๋ฅดํธ๋ ๊ณต์ค (0) | 2020.10.01 |
[python] ๋ฐฑ์ค - 1931. ํ์์ค ๋ฐฐ์ (0) | 2020.09.29 |
[python] ๋ฐฑ์ค - 1929. ์์ ๊ตฌํ๊ธฐ (0) | 2020.09.28 |
[python] ๋ฐฑ์ค - 1011. Fly me to the Alpha Centauri (0) | 2020.09.26 |