1715๋ฒ: ์นด๋ ์ ๋ ฌํ๊ธฐ
์ ๋ ฌ๋ ๋ ๋ฌถ์์ ์ซ์ ์นด๋๊ฐ ์๋ค๊ณ ํ์. ๊ฐ ๋ฌถ์์ ์นด๋์ ์๋ฅผ A, B๋ผ ํ๋ฉด ๋ณดํต ๋ ๋ฌถ์์ ํฉ์ณ์ ํ๋๋ก ๋ง๋๋ ๋ฐ์๋ A+B ๋ฒ์ ๋น๊ต๋ฅผ ํด์ผ ํ๋ค. ์ด๋ฅผํ ๋ฉด, 20์ฅ์ ์ซ์ ์นด๋ ๋ฌถ์๊ณผ 30์ฅ
www.acmicpc.net
์ค๋ช
์ ๋ ฌ๋ ๋ ๋ฌถ์์ ์ซ์ ์นด๋๊ฐ ์๋ค๊ณ ํ์. ๊ฐ ๋ฌถ์์ ์นด๋์ ์๋ฅผ A, B๋ผ ํ๋ฉด ๋ณดํต ๋ ๋ฌถ์์ ํฉ์ณ์ ํ๋๋ก ๋ง๋๋ ๋ฐ์๋ A+B ๋ฒ์ ๋น๊ต๋ฅผ ํด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด 10์ฅ, 20์ฅ, 40์ฅ์ ๋ฌถ์์ด ์๋ค๋ฉด 10์ฅ๊ณผ 20์ฅ์ ํฉ์น ๋ค, ํฉ์น 30์ฅ ๋ฌถ์๊ณผ 40์ฅ์ ํฉ์น๋ค๋ฉด (10 + 20) + (30 + 40) = 100๋ฒ์ ๋น๊ต๊ฐ ํ์ํ๋ค. ๊ทธ๋ฌ๋ 10์ฅ๊ณผ 40์ฅ์ ํฉ์น ๋ค, ํฉ์น 50์ฅ ๋ฌถ์๊ณผ 20์ฅ์ ํฉ์น๋ค๋ฉด (10 + 40) + (50 + 20) = 120 ๋ฒ์ ๋น๊ต๊ฐ ํ์ํ๋ฏ๋ก ๋ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ด๋ค.
N๊ฐ์ ์ซ์ ์นด๋ ๋ฌถ์์ ๊ฐ๊ฐ์ ํฌ๊ธฐ๊ฐ ์ฃผ์ด์ง ๋, ์ต์ํ ๋ช ๋ฒ์ ๋น๊ต๊ฐ ํ์ํ์ง๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ์ด
โ ํ ์คํธ ์ผ์ด์ค - 4 40 100 20 120 / ๊ฒฐ๊ณผ 500
4๊ฐ์ ์นด๋ ๋ฌถ์์ด ์ ๋ ฌ๋์ง ์์ ์ฑ๋ก ์๋ค. ๋น๊ตํ ํ์๊ฐ ์ต์๊ฐ ๋์ด์ผ ํ๋ฏ๋ก ๊ฐ์ฅ ์์ ๋ฌถ์๋ถํฐ ๋น๊ตํ๋ค.
1. 20 vs 40 → 20๊ณผ 40์ ๋น๊ตํ์ผ๋ฏ๋ก 20 + 40 = 60, ๋น๊ตํ์๋ 60์ด๋ค. (ํธํ๊ฒ ๋ฌถ์์ผ๋ก ๋ด๋ ๋๋ค.)
๊ทธ๋ผ ๋จ์ ๋ฌถ์๋ค์ 60 100 120์ด๋ค. ์ธ ๋ฌถ์๋ค ์ค ๊ฐ์ฅ ์์ ๊ฒ์ 60๊ณผ 100์ด๋ค. ์ด ๋์ ๋น๊ตํ๋ค.
2. 60 vs 100 → 60 + 100 = 160, ๋น๊ตํ์๋ 160์ด๋ค. ๋จ์ ๋ฌถ์๋ค์ 160 120์ด๋ค. ๋ ๋ฌถ์๋ฟ์ด๋ ๋์ ๋น๊ตํ๋ค.
3. 160 vs 120 → 160 + 120 = 280, ๋น๊ตํ์๋ 280์ด๋ค. ๋น๊ตํ ๋ฌถ์์ด ์์ผ๋ฏ๋ก ์ง๊ธ๊น์ง ๋น๊ตํ ํ์๋ฅผ ๋ํ๋ค.
4. 60 + 160 + 280 = 500, ์ต์ ๋น๊ต ํ์๋ 500์ด๋ค.
โ ์ฐ์ ์์ ํ ์ฌ์ฉ
1. ํด๋์ค ์ํฌํธ
from queue import PriorityQueue
2. ์ฐ์ ์์ ํ ์์ฑ
queue = PriorityQueue()
queue = PriorityQueue(maxmize = 10) #ํฌ๊ธฐ ์ง์
3. ์ฐ์ ์์ ํ์ ์์ ์ถ๊ฐ
queue.put(n)
4. ์ฐ์ ์์ ํ ์์ ์ญ์
queue.get() #๊ฐ์ฅ ์์ ๊ฐ์ด ๋ฐํ๋๋ค.
5. ์ ๋ ฌ ๊ธฐ์ค ๋ณ๊ฒฝ((์ฐ์ ์์, ๊ฐ))
queue.put((1, 5))
queue.get()[1] #5๊ฐ ๋ฐํ๋๋ค.
Solution
# 00:42 - 01:55 / 15:23 - 16:06
import sys
input = sys.stdin.readline
from queue import PriorityQueue #์ฐ์ ์์ ํ ํด๋์ค(queue = ๋ด์ฅ ๋ชจ๋)
#์ฐ์ ์์ ํ๋ ์ ๊ฑฐ๋ ๋ ๊ฐ์ฅ ์์ ๊ฐ์ ์ ๊ฑฐํ๋ค. ์ ๋ ฌํ ํ์๊ฐ ์๊ฒ ์ฃ ?
n = int(input())
card = [] #์นด๋ ๋ฌถ์์ ๋ด์ ๋ฆฌ์คํธ
for _ in range(n):
card.append(int(input()))
q = PriorityQueue() #์ฐ์ ์์ ํ ์์ฑ
#ํ๊ฐ ๋น ๋๊น์ง ๋ฐ๋ณต
#1. ํ์ ์นด๋๋ฌถ์์ ๋ชจ๋ ๋ฃ๊ธฐ
for i in card:
q.put(i)
#2. ์์ ๋ฌถ์ ๋ ๊ฐ๋ฅผ ๋น๊ต
res = 0 #์ถ๋ ฅํ ๊ฒฐ๊ณผ
while q.qsize() > 1: #ํ์ ๋ค์ด์๋ ๊ฐ์ด 1์ผ ๋ ๋ํ ํ์๊ฐ ์์ผ๋ฏ๋ก ํ ๊ฐ๊ฐ ๋จ์ ๋๊น์ง๋ง ๋ฐ๋ณต
x = q.get() #ํ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ ๊ฑฐํ๊ณ x์ ์ ์ฅ
sum = x + q.get() #๋ ๋ฌถ์์ ๋ํ๋ค.
res += sum #๋ํ ๊ฐ์ ๊ฒฐ๊ณผ์ ์ ์ฅํ๋ค.
q.put(sum) #๋ํ ๊ฐ์ ๋ค์ ํ์ ๋ฃ๋๋ค.
print(res)
๋ฌธ์ ๋ฅผ ์ดํดํ๋ ๋ฐ ๋ง์ ์๊ฐ์ด ์์ ๋๋ค. ์ฒ์์๋ ์ฃผ์ด์ง ์์๋ก๋ง ๋ด์๋ ์ดํด๊ฐ ๊ฐ ์ค ์์๋๋ฐ ๋ค๋ฅธ ํ ์คํธ ์ผ์ด์ค๋ค์ ๋ณด๋ ์ดํดํ ๊ฑฐ๋ ์ ํ ๋ค๋ฅด๊ฒ ๋์๋ค. ๊ฐ์ฅ ์์ ๋๋ฏธ๋ ๋น๊ต๋ฅผ ํด์ผ ํ๋๋ฐ ๊ทธ๊ฑธ ๋ฌด์ํ๊ณ ๋ํด๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ค๋ฅธ ์ฌ๋ํํ ๋ ๋ฌผ์ด๋ณด๋ฉด์ ํ๋ ค๊ณ ํ๋๋ฐ ์ฌ์ ํ ๋ชจ๋ฅด๊ฒ ์ด์ ํฌ๊ธฐํ๊ณ ์๋ค๊ฐ ๋ค์ ํ์๋๋ฐ, ์ด๋ ํ ๋ถ์ด ๋ฌธ์ ์ค๋ช ์ ์ ํด์ฃผ์ ์ ์ ์ดํดํ๊ณ ๋ฌธ์ ๋ ์ด๋ ต์ง ์๊ฒ ํ ์ ์์๋ค. ๊ทธ๋๋ ๋ฌธ์ ๋ ์ ํ์ด์ ๋คํ์ธ ๋ฏ ์ถ๋ค.
'๐งฉ Algorithm > [BOJ] Gold' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| BOJ 1339๋ฒ : ๋จ์ด ์ํ (Python/Gold 4) (0) | 2023.07.13 |
|---|---|
| BOJ 10026๋ฒ : ์ ๋ก ์์ฝ (Python/Gold 5) (1) | 2023.05.14 |