[๋ฐฑ์ค/python] 17779๋ฒ : ๊ฒ๋ฆฌ๋งจ๋๋ง 2
๋ฌธ์
์ฌํ์์ ์์ฅ ๊ตฌ์ฌํ์ ์ง๋ ๋ช ๋ ๊ฐ ๊ฒ๋ฆฌ๋งจ๋๋ง์ ํตํด์ ์์ ์ ๋น์๊ฒ ์ ๋ฆฌํ๊ฒ ์ ๊ฑฐ๊ตฌ๋ฅผ ํ์ ํ๋ค. ๊ฒฌ์ ํ ๊ถ๋ ฅ์ด ์์ด์ง ๊ตฌ์ฌํ์ ๊ถ๋ ฅ์ ๋งค์ฐ ๋ถ๋นํ๊ฒ ํ์ฌํ๊ณ , ์ฌ์ง์ด๋ ์์ ์ด๋ฆ๋ ์ฌํ์๋ก ๋ณ๊ฒฝํ๋ค. ์ด๋ฒ ์ ๊ฑฐ์์๋ ์ต๋ํ ๊ณตํํ๊ฒ ์ ๊ฑฐ๊ตฌ๋ฅผ ํ์ ํ๋ ค๊ณ ํ๋ค.
์ฌํ์๋ ํฌ๊ธฐ๊ฐ N×N์ธ ๊ฒฉ์๋ก ๋ํ๋ผ ์ ์๋ค. ๊ฒฉ์์ ๊ฐ ์นธ์ ๊ตฌ์ญ์ ์๋ฏธํ๊ณ , rํ c์ด์ ์๋ ๊ตฌ์ญ์ (r, c)๋ก ๋ํ๋ผ ์ ์๋ค. ๊ตฌ์ญ์ ๋ค์ฏ ๊ฐ์ ์ ๊ฑฐ๊ตฌ๋ก ๋๋ ์ผ ํ๊ณ , ๊ฐ ๊ตฌ์ญ์ ๋ค์ฏ ์ ๊ฑฐ๊ตฌ ์ค ํ๋์ ํฌํจ๋์ด์ผ ํ๋ค. ์ ๊ฑฐ๊ตฌ๋ ๊ตฌ์ญ์ ์ ์ด๋ ํ๋ ํฌํจํด์ผ ํ๊ณ , ํ ์ ๊ฑฐ๊ตฌ์ ํฌํจ๋์ด ์๋ ๊ตฌ์ญ์ ๋ชจ๋ ์ฐ๊ฒฐ๋์ด ์์ด์ผ ํ๋ค. ๊ตฌ์ญ A์์ ์ธ์ ํ ๊ตฌ์ญ์ ํตํด์ ๊ตฌ์ญ B๋ก ๊ฐ ์ ์์ ๋, ๋ ๊ตฌ์ญ์ ์ฐ๊ฒฐ๋์ด ์๋ค๊ณ ํ๋ค. ์ค๊ฐ์ ํตํ๋ ์ธ์ ํ ๊ตฌ์ญ์ 0๊ฐ ์ด์์ด์ด์ผ ํ๊ณ , ๋ชจ๋ ๊ฐ์ ์ ๊ฑฐ๊ตฌ์ ํฌํจ๋ ๊ตฌ์ญ์ด์ด์ผ ํ๋ค.
์ ๊ฑฐ๊ตฌ๋ฅผ ๋๋๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค.
- ๊ธฐ์ค์ (x, y)์ ๊ฒฝ๊ณ์ ๊ธธ์ด d1, d2๋ฅผ ์ ํ๋ค. (d1, d2 ≥ 1, 1 ≤ x < x+d1+d2 ≤ N, 1 ≤ y-d1 < y < y+d2 ≤ N)
- ๋ค์ ์นธ์ ๊ฒฝ๊ณ์ ์ด๋ค.
- (x, y), (x+1, y-1), ..., (x+d1, y-d1)
- (x, y), (x+1, y+1), ..., (x+d2, y+d2)
- (x+d1, y-d1), (x+d1+1, y-d1+1), ... (x+d1+d2, y-d1+d2)
- (x+d2, y+d2), (x+d2+1, y+d2-1), ..., (x+d2+d1, y+d2-d1)
- ๊ฒฝ๊ณ์ ๊ณผ ๊ฒฝ๊ณ์ ์ ์์ ํฌํจ๋์ด์๋ ๊ณณ์ 5๋ฒ ์ ๊ฑฐ๊ตฌ์ด๋ค.
- 5๋ฒ ์ ๊ฑฐ๊ตฌ์ ํฌํจ๋์ง ์์ ๊ตฌ์ญ (r, c)์ ์ ๊ฑฐ๊ตฌ ๋ฒํธ๋ ๋ค์ ๊ธฐ์ค์ ๋ฐ๋ฅธ๋ค.
- 1๋ฒ ์ ๊ฑฐ๊ตฌ: 1 ≤ r < x+d1, 1 ≤ c ≤ y
- 2๋ฒ ์ ๊ฑฐ๊ตฌ: 1 ≤ r ≤ x+d2, y < c ≤ N
- 3๋ฒ ์ ๊ฑฐ๊ตฌ: x+d1 ≤ r ≤ N, 1 ≤ c < y-d1+d2
- 4๋ฒ ์ ๊ฑฐ๊ตฌ: x+d2 < r ≤ N, y-d1+d2 ≤ c ≤ N
์๋๋ ํฌ๊ธฐ๊ฐ 7×7์ธ ์ฌํ์๋ฅผ ๋ค์ฏ ๊ฐ์ ์ ๊ฑฐ๊ตฌ๋ก ๋๋ ๋ฐฉ๋ฒ์ ์์์ด๋ค.
๊ตฌ์ญ (r, c)์ ์ธ๊ตฌ๋ A[r][c]์ด๊ณ , ์ ๊ฑฐ๊ตฌ์ ์ธ๊ตฌ๋ ์ ๊ฑฐ๊ตฌ์ ํฌํจ๋ ๊ตฌ์ญ์ ์ธ๊ตฌ๋ฅผ ๋ชจ๋ ํฉํ ๊ฐ์ด๋ค. ์ ๊ฑฐ๊ตฌ๋ฅผ ๋๋๋ ๋ฐฉ๋ฒ ์ค์์, ์ธ๊ตฌ๊ฐ ๊ฐ์ฅ ๋ง์ ์ ๊ฑฐ๊ตฌ์ ๊ฐ์ฅ ์ ์ ์ ๊ฑฐ๊ตฌ์ ์ธ๊ตฌ ์ฐจ์ด์ ์ต์๊ฐ์ ๊ตฌํด๋ณด์.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ฌํ์์ ํฌ๊ธฐ N์ด ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. rํ c์ด์ ์ ์๋ A[r][c]๋ฅผ ์๋ฏธํ๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ธ๊ตฌ๊ฐ ๊ฐ์ฅ ๋ง์ ์ ๊ฑฐ๊ตฌ์ ๊ฐ์ฅ ์ ์ ์ ๊ฑฐ๊ตฌ์ ์ธ๊ตฌ ์ฐจ์ด์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์ ๋ต
import sys
input = sys.stdin.readline
N = int(input())
area = []
for _ in range(N):
area.append(list(map(int, input().split())))
answer = 100*20*20 # ์ธ๊ตฌ ์ฐจ์ด์ ์ต๋๊ฐ์ผ๋ก ๋ฆฌ์
# ๊ธฐ์ค์ (x, y) : 0 <= x < N-2, 1 <= y < N-1
for x in range(0, N-2):
for y in range(1, N-1):
# ๊ฒฝ๊ณ์ ๊ธธ์ด d1, d2 : 1 <= d1 <= y, 1 <= d2 <= N-y
for d1 in range(1, y+1):
for d2 in range(1, N-y+1):
if 0 <= y-d1 and y+d2 < N and x+d1+d2 < N: # ์ธ๋ฑ์ค ์ฒดํฌ
cnt = [0, 0, 0, 0, 0] # 0 ~ 4 ๊ตฌ์ญ ์ธ๊ตฌ์ 0์ผ๋ก ๋ฆฌ์
# ํ์ธํ ๊ตฌ์ญ (r, c)
for r in range(N):
for c in range(N):
population = area[r][c]
if r < x+d1 and c <= y: # 0๊ตฌ์ญ
if r+c >= x+y:
cnt[4] += population
else:
cnt[0] += population
elif r <= x+d2 and y < c: # 1๊ตฌ์ญ
if r-c >= x-y:
cnt[4] += population
else:
cnt[1] += population
elif x+d1 <= r and c < y-d1+d2: # 2๊ตฌ์ญ
if r-c <= x-y+(2*d1):
cnt[4] += population
else:
cnt[2] += population
elif x+d2 < r and y-d1+d2 <= c: # 3๊ตฌ์ญ
if r+c <= x+y+(2*d2):
cnt[4] += population
else:
cnt[3] += population
else:
cnt[4] += population
answer = min(answer, max(cnt)-min(cnt))
else: # ๋ง๋ฆ๋ชจ๊ฐ area๋ฅผ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ
break
print(answer)
์ธ๋ฑ์ค ํธ์๋ฅผ ์ํด ๊ตฌ์ญ์ (0,0)์์ ์์ํ๊ณ 1~5๋ฒ ์ ๊ฑฐ๊ตฌ๋ 0~4๋ฒ ์ ๊ฑฐ๊ตฌ๋ก ์ค๋ช ํ๊ฒ ๋ค.
์ฐ์ ๋ฌธ์ ๋ฅผ ์ดํดํ๊ธฐ ์ํด ์๋์ ๊ทธ๋ฆผ์ ๊ทธ๋ ค๋ณด์๋ค.
๊ฐ์ฅ ์์ ์๋ ๊ผญ์ง์ ์ ๊ธฐ์ค์ (x, y)๋ก ์ค์ ํ๊ณ ๊ฒฝ๊ณ์ ๊ธธ์ด d1, d2์ผ ๋์ ์ํฉ์ ์ ๋ฆฌํ๋ฉด
์ ๊ทธ๋ฆผ๊ณผ ๊ฐ๊ณ ์ขํ์ ๋ฒ์๋ฅผ ํ๋์ ํ์ ํ๊ธฐ ์ฝ๋ค.
answer = 100*20*20 # ์ธ๊ตฌ ์ฐจ์ด์ ์ต๋๊ฐ์ผ๋ก ๋ฆฌ์
# ๊ธฐ์ค์ (x, y) : 0 <= x < N-2, 1 <= y < N-1
for x in range(0, N-2):
for y in range(1, N-1):
# ๊ฒฝ๊ณ์ ๊ธธ์ด d1, d2 : 1 <= d1 <= y, 1 <= d2 <= N-y
for d1 in range(1, y+1):
for d2 in range(1, N-y+1):
if 0 <= y-d1 and y+d2 < N and x+d1+d2 < N: # ์ธ๋ฑ์ค ์ฒดํฌ
cnt = [0, 0, 0, 0, 0] # 0 ~ 4 ๊ตฌ์ญ ์ธ๊ตฌ์ 0์ผ๋ก ๋ฆฌ์
๊ฐ ๊ตฌ์ญ์ ์ต๋ ์ธ๊ตฌ๋ 100์ด๊ณ ํฌ๊ธฐ์ ์ต๋๋ 20*20์ด๋ฏ๋ก
์ธ๊ตฌ ์ฐจ์ด์ ์ต๋๊ฐ์ 100*20*20์ด๋ฉฐ answer๋ฅผ ์ธ๊ตฌ ์ฐจ์ด์ ์ต๋๊ฐ์ผ๋ก ์ด๊ธฐํํ๋ค.
๊ฐ๋ฅํ ๋ชจ๋ ๊ธฐ์ค์ ์์ ๊ฒฝ๊ณ์ ๊ธธ์ด๋ฅผ ๋๋ ค๊ฐ๋ฉฐ ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ํ์ํ๋ค.
๊ฒฝ๊ณ d1, d2๋ ์ต์ 1 ์ด์์ด๊ธฐ ๋๋ฌธ์
๊ธฐ์ค์ x๋ 0 <= x < N-2. ๊ธฐ์ค์ y๋ 1 <= y < N-1 ์ ๋ฒ์๋ฅผ ๊ฐ๋๋ค.
๋ฌธ์ ์์ 1 ≤ y-d1 < y < y+d2 ≤ N ์ด๋ผ ์ค๋ช ํ๋ฏ๋ก ๊ณ์ฐํด๋ณด๋ฉด
๊ฒฝ๊ณ d1์ 1 <= d1 <= y, ๊ฒฝ๊ณ d2๋ 1 <= d2 <= N-y ์ ๋ฒ์๋ฅผ ๊ฐ๋๋ค.
์ดํด๊ฐ ์๋๋ค๋ฉด ์ ๊ทธ๋ฆผ์ ์ฐธ๊ณ ํ๋ฉด ์ดํดํ๊ธฐ ์ฝ๋ค.
์ ๊ทธ๋ฆผ์์ ํ์ ํ ์ขํ์ ๋ฒ์๋ฅผ ํ ๋๋ก ์ธ๋ฑ์ค๋ฅผ ์ฒดํฌํด์ค๋ค.
๋ง์ฝ ์ธ๋ฑ์ค๋ฅผ ๋ฒ์ด๋ฌ๋ค๋ฉด ๋์ด์ ๊ฒฝ๊ณ๋ฅผ ๋๋ฆด ํ์๊ฐ ์์ผ๋ฏ๋ก break ํ๋ค.
cnt์๋ ๊ฐ ๊ตฌ์ญ์ ์ธ๊ตฌ์์ ํฉ์ ์ ์ฅํ ๊ฒ์ด๋ฏ๋ก 0์ผ๋ก ์ด๊ธฐํํด์ค๋ค.
์ด์ ๋ชจ๋ ์ขํ๋ฅผ ๋๋ฉฐ ์ด๋ ๊ตฌ์ญ์ ํด๋นํ๋์ง ํ์ธํ๋ค.
์๋ ๊ทธ๋ฆผ์ ๊ฐ ๊ตฌ์ญ์ ์ขํ๊ฐ ์ด๋ค ๊ท์น์ด ์๋์ง ํ์ ํ๊ธฐ ์ํด ๊ทธ๋ ค๋ณธ ๊ทธ๋ฆผ์ด๋ค.
ํ๋ ์ ์ ๊ฐ ์ ๊ฑฐ๊ตฌ์ ๊ฒฝ๊ณ๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋ ์ ์ด๋ค.
๊ฐ ์ ๊ฑฐ๊ตฌ ์์์ 4๋ฒ ์ ๊ฑฐ๊ตฌ์ ํด๋นํ๋ ๊ตฌ์ญ (r, c)๋ ๋ณด๋ผ์ ๊ธ์จ์ ๊ฐ์ ๊ท์น์ ๊ฐ๋๋ค.
๋ณด๋ผ์ ๊ธ์จ์ ๊ท์น์ ํ๋ ๋๊ทธ๋ผ๋ฏธ ์ขํ ์ค ํ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์์ฑ๋์๋ค.
(r, c)๊ฐ ๋ค ๊ตฌ์ญ ์ค ์ด๋์ ์๋์ง ํ์ธํ๊ณ
๋ณด๋ผ์ ๊ธ์จ์ ๊ฐ์ ๊ท์น์ ๊ธฐ๋ฐ์ผ๋ก 4 ์ ๊ฑฐ๊ตฌ์ธ์ง ์ฒดํฌํ์ฌ
ํด๋น ์ ๊ฑฐ๊ตฌ ์ธ๋ฑ์ค์ cnt ๊ฐ์ (r, c) ๊ตฌ์ญ์ ๊ฐ์ ๋ํด์ค๋ค.
๋ชจ๋ ์ ๊ฑฐ๊ตฌ์ ๊ณ์ฐ์ด ๋๋ฌ์ผ๋ฉด
cnt์ ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐจ์ answer์ ๋น๊ตํ์ฌ ๋ ์์ ๊ฐ์ answer์ ์ ์ฅํ๋ค.
'๐์๊ณ ๋ฆฌ์ฆ > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค/python] 19238๋ฒ : ์คํํธ ํ์ (0) | 2021.09.22 |
---|---|
[๋ฐฑ์ค/python] 11660๋ฒ : ๊ตฌ๊ฐ ํฉ ๊ตฌํ๊ธฐ 5 (0) | 2021.09.20 |
[๋ฐฑ์ค/python] 7490๋ฒ : 0 ๋ง๋ค๊ธฐ (0) | 2021.09.17 |
[๋ฐฑ์ค/python] 1987๋ฒ : ์ํ๋ฒณ (0) | 2021.09.16 |
[๋ฐฑ์ค/python] 1927๋ฒ : ์ต์ ํ (0) | 2021.09.06 |