๐ค๋ฌธ์ ํด๊ฒฐ
1. D4 | MST - prim
2. ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผ ๊ฐ์ผ๋ก ํ๋ ์ธ์ ํ๋ ฌ์ ๋ง๋ ๋ค
3. ์ต์ ๊ฐ์ ๊ฐฑ์ ํด์ค ๊ฐ์ค์น ๋ฆฌ์คํธ, MST์ ํฌํจ๋์ง ์ฒดํฌํ๋ ๋ฆฌ์คํธ, ๋ถ๋ชจ๋ ธ๋ ์ ํ๋ฆฌ์คํธ๋ฅผ ๋ง๋ ๋ค.
(์ฌ๊ธฐ์๋ ๋ชจ๋ ๋ ธ๋๊ฐ ์ฐ๊ฒฐ๋ ์ ์๊ธฐ ๋๋ฌธ์ ๋ถ๋ชจ๋ ธ๋๋ ํ์ํ์ง ์์ ์ ์์)
4. ์์์ ์ ์ ํ(์ฌ๊ธฐ์๋ 0)ํ๊ณ ๊ฐ์ ์ ๋๋ฉฐ ํ์ํ๋ค
(1) ์์ง MST์ ํฌํจ๋์ด ์์ง ์๊ณ , ๊ฐ์ค์น๊ฐ ์ต์์ธ ์ ์ u๋ฅผ ์ฐพ๋๋ค.
(2) u๋ฅผ MST์ ํฌํจ์ํค๊ณ , ๊ทธ ๊ฐ์ค์น๋ฅผ ๊ฒฐ๊ณผ๊ฐ์ ๋ํด์ค๋ค.
(3) ๊ฐ์ค์น๋ฅผ ์ต์๊ฐ์ผ๋ก ๊ฐฑ์ ํ๊ธฐ ์ํด u์ ์ธ์ ํ๊ณ ์์ง mst๊ฐ ์๋ ์ ์ (w) ์ค์์ key[w] > u-w ์ด๋ฉด ๊ฐฑ์ ํ๋ค
5. ๋ชจ๋ ๋ ธ๋๋ฅผ ์ ํํ ๋๊น์ง 4๋ฒ์ ๋ฐ๋ณตํ๋ค.
๐จ ์ต์์ ์ฅํธ๋ฆฌ ์๊ณ ๋ฆฌ์ฆ, ํฌ๋ฃจ์ค์นผ๊ณผ ํ๋ฆผ์ค์์ ํ๋ฆผ์ ์ ํํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํจ.
๐ป์์ค ์ฝ๋
for tc in range(1, 1+int(input())):
n = int(input()) # ์ฌ์ ๊ฐฏ์
x = list(map(int, input().split())) # ์ฌ์ x ์ขํ
y = list(map(int, input().split())) # ์ฌ์ y ์ขํ
E = float(input()) # ์ธ์จ
# ์ธ์ ํ๋ ฌ ์์ฑ
adj = [[0]*n for _ in range(n)]
for i in range(n):
for j in range(n):
adj[i][j] = ((x[i]-x[j])**2 + (y[i]-y[j])**2)
adj[j][i] = ((x[i]-x[j])**2 + (y[i]-y[j])**2)
# for row in adj:
# print(row)
# key ๊ฐ์ค์น, mst ๋ฐฉ๋ฌธ ๊ฐ๋
, p ์ฐ๊ฒฐ ๋
ธ๋
INF = float('inf')
key = [INF]*n
mst = [False]*n
p = [-1]*n
# ์์์ ์ ํ: ๋๋ 0์ ํํจ
key[0] = 0
cnt = 0
result = 0
while cnt < n:
# ์์ง mst๊ฐ ์๋๊ณ key๊ฐ ์ต์์ธ ์ ์ ์ ํ : u
minKey = INF
u = -1
for i in range(n):
if not mst[i] and key[i] < minKey:
minKey = key[i]
u = i
# u๋ฅผ mst๋ก ์ ํ
mst[u] = True
result += minKey
cnt +=1
# key๊ฐ์ ๊ฐฑ์
# u์ ์ธ์ ํ๊ณ ์์ง mst๊ฐ ์๋ ์ ์ w์์ key[w] > u-w ์ด๋ฉด ๊ฐฑ์
for w in range(n):
if adj[u][w] > 0 and not mst[w] and key[w] > adj[u][w]:
key[w] = adj[u][w]
p[w] = u # ๋ํํ
์ฐพ์์ค๋ ์น๊ตฌ
print('#{} {}'.format(tc, round(result*E)))
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: SW Expert Academy
๋น์ ์ ์ธ๋๋ค์์ ๋ด์ N๊ฐ์ ์ฌ๋ค์ ์ฐ๊ฒฐํ๋ ๊ตํต์์คํ
์ค๊ณ ํ๋ก์ ํธ์ธ ‘ํ๋๋ก’๋ฅผ ์งํํ๊ฒ ๋์์ต๋๋ค.
ํ๋๋ก ํ๋ก์ ํธ๋ ์ฒํด์ ์์ฐ์ ๊ฐ์ง ์ธ๋๋ค์์์ ๊ฐ ์ฌ ๊ฐ ๊ตํต์ด ์ํํ์ง ์์ ๊ด๊ด ์ฐ์
์ ๋ฐ์ ์ ์ ํดํ๋ ์์๋ฅผ ์ค์ด๊ณ ๋ถ๊ฐ ๊ฐ์น๋ฅผ ์ฐฝ์ถํ๊ณ ์ ์งํํ๋ ํ๋ก์ ํธ์
๋๋ค.
๋ณธ ํ๋ก์ ํธ์์๋ ์ธ๋๋ค์์ ๋ด์ ๋ชจ๋ ์ฌ์ ํด์ ํฐ๋๋ก ์ฐ๊ฒฐํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค.
ํด์ ํฐ๋์ ๋ฐ๋์ ๋ ์ฌ์ ์ ๋ถ์ผ๋ก ์ฐ๊ฒฐํ๋ฉฐ, ๋ ํด์ ํฐ๋์ด ๊ต์ฐจ๋๋ค ํ๋๋ผ๋ ๋ฌผ๋ฆฌ์ ์ผ๋ก๋ ์ฐ๊ฒฐ๋์ง ์๋ ๊ฒ์ผ๋ก ๊ฐ์ ํฉ๋๋ค.
์๋ ๊ทธ๋ฆผ 1๊ณผ ๊ฐ์ ๊ฒฝ์ฐ, A์ฌ์์ D์ฌ์ผ๋ก๋ ์ฐ๊ฒฐ๋์์ง๋ง A์ฌ์ผ๋ก๋ถํฐ B์ฌ, C์ฌ์๋ ๋๋ฌ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์ฐ๊ฒฐ๋์ง ์์ ๊ฒ์
๋๋ค.
๋ค์ ๋ ๊ฐ์ง์ ๊ฒฝ์ฐ๋ ๋ชจ๋ ์ฌ์ด ์ฐ๊ฒฐ๋ ๊ฒ์
๋๋ค.
์์ ๊ฐ์ ๋ฐฉ๋ฒ์ ํตํด ์ธ๋๋ค์์ ๋ด์ ๋ชจ๋ ์ฌ๋ค์ ์ฐ๊ฒฐํด์ผ ํ๋ ํ๋ก์ ํธ์
๋๋ค.
๊ทธ๋ฆผ 3์์ B์ A์ฒ๋ผ ์ง์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ๊ฒฝ์ฐ๋ ์์ง๋ง, B์ C์ฒ๋ผ ์ฌ๋ฌ ์ฌ์ ๊ฑธ์ณ ๊ฐ์ ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
๋ค๋ง ์ธ๋๋ค์์์์๋ ํด์ ํฐ๋ ๊ฑด์ค๋ก ์ธํด ํ๊ดด๋๋ ์์ฐ์ ์ํด ๋ค์๊ณผ ๊ฐ์ ํ๊ฒฝ ๋ถ๋ด๊ธ ์ ์ฑ
์ด ์์ต๋๋ค.
- ํ๊ฒฝ ๋ถ๋ด ์ธ์จ(E)๊ณผ ๊ฐ ํด์ ํฐ๋ ๊ธธ์ด(L)์ ์ ๊ณฑ์ ๊ณฑ(E * L2)๋งํผ ์ง๋ถ
์ด ํ๊ฒฝ ๋ถ๋ด๊ธ์ ์ต์๋ก ์ง๋ถํ๋ฉฐ, N๊ฐ์ ๋ชจ๋ ์ฌ์ ์ฐ๊ฒฐํ ์ ์๋ ๊ตํต ์์คํ
์ ์ค๊ณํ์์ค.
64๋นํธ integer ๋ฐ double๋ก ์ฒ๋ฆฌํ์ง ์์ ๊ฒฝ์ฐ, overflow๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค (C/C++ ์์ 64๋นํธ integer๋ long long ์ผ๋ก ์ ์ธ).
์์ ๊ทธ๋ฆผ 2์ ํ๊ฒฝ ๋ถ๋ด๊ธ์ ์ต์๋ก ํ๋ฉฐ ๋ชจ๋ ์ฌ์ ์ฐ๊ฒฐํ๊ณ ์์ง๋ง, ๊ทธ๋ฆผ 3๋ ๊ทธ๋ ์ง ์์์ ์ ์ ์์ต๋๋ค.
[์
๋ ฅ]
๊ฐ์ฅ ์ฒซ ์ค์ ์ ์ฒด ํ
์คํธ ์ผ์ด์ค์ ์์ด๋ค.
๊ฐ ํ
์คํธ ์ผ์ด์ค์ ์ฒซ ์ค์๋ ์ฌ์ ๊ฐ์ N์ด ์ฃผ์ด์ง๊ณ (1≤N≤1,000),
๋ ๋ฒ์งธ ์ค์๋ ๊ฐ ์ฌ๋ค์ ์ ์์ธ X์ขํ, ์ธ ๋ฒ์งธ ์ค์๋ ๊ฐ ์ฌ๋ค์ ์ ์์ธ Y์ขํ๊ฐ ์ฃผ์ด์ง๋ค (0≤X≤1,000,000, 0≤Y≤1,000,000).
๋ง์ง๋ง์ผ๋ก, ํด์ ํฐ๋ ๊ฑด์ค์ ํ๊ฒฝ ๋ถ๋ด ์ธ์จ ์ค์ E๊ฐ ์ฃผ์ด์ง๋ค (0≤E≤1).
[์ถ๋ ฅ]
๊ฐ ํ
์คํธ ์ผ์ด์ค์ ๋ต์ ์์๋๋ก ์ถ๋ ฅํ๋ฉฐ, ๊ฐ ์ผ์ด์ค๋ง๋ค ์ค์ ์์์ “#C”๋ฅผ ์ถ๋ ฅํ์ฌ์ผ ํ๋ค. ์ด๋ C๋ ์ผ์ด์ค์ ๋ฒํธ์ด๋ค.
๊ฐ์ ์ค์ ๋น์นธ์ ํ๋ ๋๊ณ , ์ฃผ์ด์ง ์
๋ ฅ์์ ๋ชจ๋ ์ฌ๋ค์ ์๋ ์ต์ ํ๊ฒฝ ๋ถ๋ด๊ธ์ ์์ ์ฒซ์งธ ์๋ฆฌ์์ ๋ฐ์ฌ๋ฆผํ์ฌ ์ ์ ํํ๋ก ์ถ๋ ฅํ๋ผ.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] SWEA - 1861. ์ ์ฌ๊ฐํ ๋ฐฉ (0) | 2020.08.14 |
---|---|
[python] SWEA - 1258. [S/W ๋ฌธ์ ํด๊ฒฐ ์์ฉ] 7์ผ์ฐจ - ํ๋ ฌ์ฐพ๊ธฐ (0) | 2020.08.13 |
[python] SWEA - 1218. [S/W ๋ฌธ์ ํด๊ฒฐ ๊ธฐ๋ณธ] 4์ผ์ฐจ - ๊ดํธ ์ง์ง๊ธฐ (0) | 2020.08.11 |
[python] SWEA - 1226. [S/W ๋ฌธ์ ํด๊ฒฐ ๊ธฐ๋ณธ] 7์ผ์ฐจ - ๋ฏธ๋ก1 (2) | 2020.08.10 |
[python] SWEA - 1249. [S/W ๋ฌธ์ ํด๊ฒฐ ์์ฉ] 4์ผ์ฐจ - ๋ณด๊ธ๋ก (2) | 2020.08.09 |