https://www.acmicpc.net/problem/15686
๋ฌธ์
ํฌ๊ธฐ๊ฐ NรN์ธ ๋์๊ฐ ์๋ค. ๋์๋ 1ร1ํฌ๊ธฐ์ ์นธ์ผ๋ก ๋๋์ด์ ธ ์๋ค. ๋์์ ๊ฐ ์นธ์ ๋น ์นธ, ์นํจ์ง, ์ง ์ค ํ๋์ด๋ค. ๋์์ ์นธ์ (r, c)์ ๊ฐ์ ํํ๋ก ๋ํ๋ด๊ณ , rํ c์ด ๋๋ ์์์๋ถํฐ r๋ฒ์งธ ์นธ, ์ผ์ชฝ์์๋ถํฐ c๋ฒ์งธ ์นธ์ ์๋ฏธํ๋ค. r๊ณผ c๋ 1๋ถํฐ ์์ํ๋ค.
์ด ๋์์ ์ฌ๋ ์ฌ๋๋ค์ ์นํจ์ ๋งค์ฐ ์ข์ํ๋ค. ๋ฐ๋ผ์, ์ฌ๋๋ค์ "์นํจ ๊ฑฐ๋ฆฌ"๋ผ๋ ๋ง์ ์ฃผ๋ก ์ฌ์ฉํ๋ค. ์นํจ ๊ฑฐ๋ฆฌ๋ ์ง๊ณผ ๊ฐ์ฅ ๊ฐ๊น์ด ์นํจ์ง ์ฌ์ด์ ๊ฑฐ๋ฆฌ์ด๋ค. ์ฆ, ์นํจ ๊ฑฐ๋ฆฌ๋ ์ง์ ๊ธฐ์ค์ผ๋ก ์ ํด์ง๋ฉฐ, ๊ฐ๊ฐ์ ์ง์ ์นํจ ๊ฑฐ๋ฆฌ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ๋์์ ์นํจ ๊ฑฐ๋ฆฌ๋ ๋ชจ๋ ์ง์ ์นํจ ๊ฑฐ๋ฆฌ์ ํฉ์ด๋ค.
์์์ ๋ ์นธ (r1, c1)๊ณผ (r2, c2) ์ฌ์ด์ ๊ฑฐ๋ฆฌ๋ |r1-r2| + |c1-c2|๋ก ๊ตฌํ๋ค.
์๋ฅผ ๋ค์ด, ์๋์ ๊ฐ์ ์ง๋๋ฅผ ๊ฐ๋ ๋์๋ฅผ ์ดํด๋ณด์.
0์ ๋น ์นธ, 1์ ์ง, 2๋ ์นํจ์ง์ด๋ค.
(2, 1)์ ์๋ ์ง๊ณผ (1, 2)์ ์๋ ์นํจ์ง๊ณผ์ ๊ฑฐ๋ฆฌ๋ |2-1| + |1-2| = 2, (5, 5)์ ์๋ ์นํจ์ง๊ณผ์ ๊ฑฐ๋ฆฌ๋ |2-5| + |1-5| = 7์ด๋ค. ๋ฐ๋ผ์, (2, 1)์ ์๋ ์ง์ ์นํจ ๊ฑฐ๋ฆฌ๋ 2์ด๋ค.
(5, 4)์ ์๋ ์ง๊ณผ (1, 2)์ ์๋ ์นํจ์ง๊ณผ์ ๊ฑฐ๋ฆฌ๋ |5-1| + |4-2| = 6, (5, 5)์ ์๋ ์นํจ์ง๊ณผ์ ๊ฑฐ๋ฆฌ๋ |5-5| + |4-5| = 1์ด๋ค. ๋ฐ๋ผ์, (5, 4)์ ์๋ ์ง์ ์นํจ ๊ฑฐ๋ฆฌ๋ 1์ด๋ค.
์ด ๋์์ ์๋ ์นํจ์ง์ ๋ชจ๋ ๊ฐ์ ํ๋์ฐจ์ด์ฆ์ด๋ค. ํ๋ ์ฐจ์ด์ฆ ๋ณธ์ฌ์์๋ ์์ต์ ์ฆ๊ฐ์ํค๊ธฐ ์ํด ์ผ๋ถ ์นํจ์ง์ ํ์ ์ํค๋ ค๊ณ ํ๋ค. ์ค๋ ์ฐ๊ตฌ ๋์ ์ด ๋์์์ ๊ฐ์ฅ ์์ต์ ๋ง์ด ๋ผ ์ ์๋ ์นํจ์ง์ ๊ฐ์๋ ์ต๋ M๊ฐ๋ผ๋ ์ฌ์ค์ ์์๋ด์๋ค.
๋์์ ์๋ ์นํจ์ง ์ค์์ ์ต๋ M๊ฐ๋ฅผ ๊ณ ๋ฅด๊ณ , ๋๋จธ์ง ์นํจ์ง์ ๋ชจ๋ ํ์ ์์ผ์ผ ํ๋ค. ์ด๋ป๊ฒ ๊ณ ๋ฅด๋ฉด, ๋์์ ์นํจ ๊ฑฐ๋ฆฌ๊ฐ ๊ฐ์ฅ ์๊ฒ ๋ ์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N(2 โค N โค 50)๊ณผ M(1 โค M โค 13)์ด ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๋์์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋ค.
๋์์ ์ ๋ณด๋ 0, 1, 2๋ก ์ด๋ฃจ์ด์ ธ ์๊ณ , 0์ ๋น ์นธ, 1์ ์ง, 2๋ ์นํจ์ง์ ์๋ฏธํ๋ค. ์ง์ ๊ฐ์๋ 2N๊ฐ๋ฅผ ๋์ง ์์ผ๋ฉฐ, ์ ์ด๋ 1๊ฐ๋ ์กด์ฌํ๋ค. ์นํจ์ง์ ๊ฐ์๋ M๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 13๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ํ์ ์ํค์ง ์์ ์นํจ์ง์ ์ต๋ M๊ฐ๋ฅผ ๊ณจ๋์ ๋, ๋์์ ์นํจ ๊ฑฐ๋ฆฌ์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์์
์กฐ๊ฑด
- ์๊ฐ ์ ํ: 1์ด
- ๋ฉ๋ชจ๋ฆฌ ์ ํ: 512MB
์ฝ๋
from itertools import combinations
import sys
input = sys.stdin.readline
# ์
๋ ฅ
N,M = map(int,input().split())
graph = [list(map(int,input().split())) for _ in range(N)]
ck = []
home = []
# ์นํจ์ง๊ณผ ์ง์ ์์น ์ฐพ๊ธฐ
for i in range(N):
for j in range(N):
if graph[i][j] == 1:
home.append((i,j))
elif graph[i][j] == 2:
ck.append((i,j))
# M๊ฐ์ ์นํจ์ง ์กฐํฉ
result = sys.maxsize
for comb in combinations(ck,M): # ๋ชจ๋ ์กฐํฉ์ ํ์
city_chicken = 0 # ๋์ ์นํจ ๊ฑฐ๋ฆฌ
for h in home: # ๊ฐ ์ง๋ณ๋ก ๊ฐ์ฅ ๊ฐ๊น์ด ์นํจ ๊ฑฐ๋ฆฌ๋ฅผ ์ฐพ์ ํฉํจ
shortest_ck = sys.maxsize # ๊ฐ ์ง๋ง๋ค ์นํจ ๊ฑฐ๋ฆฌ
for c in comb:
shortest_ck = min(shortest_ck, abs(h[0]-c[0])+abs(h[1]-c[1]))
city_chicken += shortest_ck
result = min(result,city_chicken)
# ์ถ๋ ฅ
print(result)
๊ทธ๋ํ๋ฅผ ํ์ํ๋ฉด์ ์นํจ์ง๊ณผ ์ง์ ์์น๋ฅผ ์ฐพ์ ์ ์ฅํด์ค๋ค.
๋์์์ ํ์ ์ํค์ง ์๊ณ ๊ณ ๋ฅผ ์ ์๋ ์นํจ์ง์ ๊ฐ์๊ฐ M๊ฐ์ด๋ฏ๋ก,
combinations
๋ฅผ ์ฌ์ฉํ์ฌ ์นํจ์ง์์ M๊ฐ๋ฅผ ๋ฝ์ ์กฐํฉ์ ์์ฑํ๋ค.
๊ฐ ์ง์์ ๊ฐ์ฅ ๊ฐ๊น์ด ์นํจ์ง์ ์์๋ด๊ธฐ ์ํด์, ์ด์ค for๋ฌธ์ ์ฌ์ฉํ๋ค.
for h in home: # ๊ฐ ์ง๋ณ๋ก ๊ฐ์ฅ ๊ฐ๊น์ด ์นํจ ๊ฑฐ๋ฆฌ๋ฅผ ์ฐพ์ ํฉํจ
shortest_ck = sys.maxsize # ๊ฐ ์ง๋ง๋ค ์นํจ ๊ฑฐ๋ฆฌ
for c in comb:
shortest_ck = min(shortest_ck, abs(h[0]-c[0])+abs(h[1]-c[1]))
city_chicken += shortest_ck
์ต์ข ์ ์ผ๋ก ๊ตฌํด์ง ๊ฐ ์กฐํฉ๋ณ ๋์ ์นํจ ๊ฑฐ๋ฆฌ์ ์ต์๊ฐ์
result
์ ์ ์ฅํ๋ค.
result = min(result,city_chicken)
๋๋ ์ & ๋ฐฐ์ด ์