[BOJ][๐ก4][๋ฐฑ์ค#14938] ์๊ฐ๊ทธ๋ผ์ด๋
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold IV
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์์์ด๋ ์์ฆ ๊ฐ์ฅ ์ธ๊ธฐ๊ฐ ์๋ ๊ฒ์ ์๊ฐ๊ทธ๋ผ์ด๋๋ฅผ ์ฆ๊ธฐ๊ณ ์๋ค. ์๊ฐ๊ทธ๋ผ์ด๋๋ ์ฌ๋ฌ ์ง์ญ์ค ํ๋์ ์ง์ญ์ ๋ํ์ฐ์ ํ๊ณ ๋ํํ์ฌ, ๊ทธ ์ง์ญ์ ๋จ์ด์ ธ ์๋ ์์ดํ ๋ค์ ์ด์ฉํด ์๋ฐ์ด๋ฒ์ ํ๋ ๊ฒ์์ด๋ค. ์๊ฐ๊ทธ๋ผ์ด๋์์ 1๋ฑ์ ํ๋ฉด ๋ณด์์ผ๋ก ์นํจ์ ์ฃผ๋๋ฐ, ์์์ด๋ ๋จ ํ๋ฒ๋ ์นํจ์ ๋จน์ ์๊ฐ ์์๋ค. ์์ ์ด ์นํจ์ ๋ชป ๋จน๋ ์ด์ ๋ ์ค๋ ฅ ๋๋ฌธ์ด ์๋๋ผ ์์ดํ ์ด์ด ์์ด์๋ผ๊ณ ์๊ฐํ ์์์ด๋ ๋ํ์ฐ์์ ๋จ์ด์ง ๋ ๊ฐ ์ง์ญ์ ์์ดํ ๋ค์ด ๋ช ๊ฐ ์๋์ง ์๋ ค์ฃผ๋ ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฐ์ ํ์์ง๋ง ์ด๋๋ก ๋ํํด์ผ ์์ ์ ์์ ๋ฒ์ ๋ด์์ ๊ฐ์ฅ ๋ง์ ์์ดํ ์ ์ป์ ์ ์๋์ง ์ ์ ์์๋ค. ๊ฐ ์ง์ญ์ ์ผ์ ํ ๊ธธ์ด l (1 โค l โค 15)์ ๊ธธ๋ก ๋ค๋ฅธ ์ง์ญ๊ณผ ์ฐ๊ฒฐ๋์ด ์๊ณ ์ด ๊ธธ์ ์๋ฐฉํฅ ํตํ์ด ๊ฐ๋ฅํ๋ค. ์์์ด๋ ๋ํํ ์ง์ญ์ ์ค์ฌ์ผ๋ก ๊ฑฐ๋ฆฌ๊ฐ ์์ ๋ฒ์ m (1 โค m โค 15) ์ด๋ด์ ๋ชจ๋ ์ง์ญ์ ์์ดํ ์ ์ต๋ ๊ฐ๋ฅํ๋ค๊ณ ํ ๋, ์์์ด๊ฐ ์ป์ ์ ์๋ ์์ดํ ์ ์ต๋ ๊ฐ์๋ฅผ ์๋ ค์ฃผ์.
์ฃผ์ด์ง ํ๋๊ฐ ์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ๊ณ , ์์์ด์ ์์๋ฒ์๊ฐ 4๋ผ๊ณ ํ์. ( ์ ๋ฐ์ ์ซ์๋ ์ง์ญ ๋ฒํธ, ์์ ์ซ์๋ ์์ดํ ์, ์ ์์ ์ซ์๋ ๊ฑฐ๋ฆฌ๋ฅผ ์๋ฏธํ๋ค) ์์์ด๊ฐ 2๋ฒ ์ง์ญ์ ๋จ์ด์ง๊ฒ ๋๋ฉด 1๋ฒ,2๋ฒ(์๊ธฐ ์ง์ญ), 3๋ฒ, 5๋ฒ ์ง์ญ์ ๋๋ฌํ ์ ์๋ค. (4๋ฒ ์ง์ญ์ ๊ฒฝ์ฐ ๊ฐ๋ ๊ฑฐ๋ฆฌ๊ฐ 3 + 5 = 8 > 4(์์๋ฒ์) ์ด๋ฏ๋ก 4๋ฒ ์ง์ญ์ ์์ดํ ์ ์ป์ ์ ์๋ค.) ์ด๋ ๊ฒ ๋๋ฉด ์์์ด๋ 23๊ฐ์ ์์ดํ ์ ์ป์ ์ ์๊ณ , ์ด๋ ์์ ํ๋์์ ์์์ด๊ฐ ์ป์ ์ ์๋ ์์ดํ ์ ์ต๋ ๊ฐ์์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์๋ ์ง์ญ์ ๊ฐ์ n (1 โค n โค 100)๊ณผ ์์์ด์ ์์๋ฒ์ m (1 โค m โค 15), ๊ธธ์ ๊ฐ์ r (1 โค r โค 100)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ n๊ฐ์ ์ซ์๊ฐ ์ฐจ๋ก๋๋กย ๊ฐ ๊ตฌ์ญ์ ์๋ ์์ดํ ์ ์ t (1 โค t โค 30)๋ฅผ ์๋ ค์ค๋ค. ์ธ ๋ฒ์งธ ์ค๋ถํฐ r+2๋ฒ์งธ ์ค ๊น์ง ๊ธธ ์ ๋์ ์กด์ฌํ๋ ์ง์ญ์ ๋ฒํธ a, b, ๊ทธ๋ฆฌ๊ณ ๊ธธ์ ๊ธธ์ด l (1 โค l โค 15)๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์์์ด๊ฐ ์ป์ ์ ์๋ ์ต๋ ์์ดํ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
5 5 4
5 7 8 2 3
1 4 5
5 2 4
3 2 3
1 2 3
์ถ๋ ฅ
23
My Sol
import sys
input = sys.stdin.readline
from heapq import heappop, heappush
def check(s):
visit = [0]*(V+1)
Q = [(0, s)]
nowFarm = 0
while Q:
dis, u = heappop(Q)
if dis > M: continue
if visit[u]: continue
visit[u] = 1
nowFarm += arr[u]
for v, w in G[u]:
heappush(Q, (dis+w, v))
return nowFarm
V, M, E = map(int, input().split())
arr = [0] + list(map(int, input().split()))
G = [[] for _ in range(V+1)]
for _ in range(E):
u, v, w = map(int, input().split())
G[u].append((v, w))
G[v].append((u, w))
maxFarm = 0
for s in range(1, V+1):
maxFarm = max(maxFarm, check(s))
print(maxFarm)
๋ชจ๋ ์ง์ ์ ์์์ ์ผ๋ก ํ์ฌ ๊ฐ๋ฅํ ๊ฑฐ๋ฆฌ๋งํผ ๊ฐ๋ณด๋ฉฐ ํด๋น ์ง์ ์ ์์ดํ ๊ฐ์ ๋ํ๋ ๋ฐฉ์์ ์ฌ์ฉํ์๋ค. ๋งค ์ง์ ์ ๋ค๋ฌ ๋งค๋ฒ ํ์ธํ๋ฏ๋ก ์์ ํ์์ ํ์ง๋ง, N์ด ์ต๋ 100์ด๋ฏ๋ก ์ถฉ๋ถํ ๊ฐ๋ฅํ ๊ฒ์ผ๋ก ๋ณด์๋ค.
dis๊ฐ ์ ์ ์์ผ๋ก ๋ฝ์์ visit์ ์ฒดํฌํ๊ฒ ํ๋ ค๊ณ heapq๋ฅผ ์ฌ์ฉํ์๋ค.
72ms์ ๋น ๋ฅธ ์๋ต์๊ฐ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋๊ธ๋จ๊ธฐ๊ธฐ