[BOJ][๐ก5][๋ฐฑ์ค#02212] ์ผ์
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
ํ๊ตญ๋๋ก๊ณต์ฌ๋ ๊ณ ์๋๋ก์ ์ ๋น์ฟผํฐ์คํ๋ฅผ ์ํด ๊ณ ์๋๋ก ์์ N๊ฐ์ ์ผ์๋ฅผ ์ค์นํ์๋ค. ๋ฌธ์ ๋ ์ด ์ผ์๋ค์ด ์์งํ ์๋ฃ๋ค์ ๋ชจ์ผ๊ณ ๋ถ์ํ ๋ช ๊ฐ์ ์ง์ค๊ตญ์ ์ธ์ฐ๋ ์ผ์ธ๋ฐ, ์์ฐ์์ ๋ฌธ์ ๋ก, ๊ณ ์๋๋ก ์์ ์ต๋ K๊ฐ์ ์ง์ค๊ตญ์ ์ธ์ธ ์ ์๋ค๊ณ ํ๋ค. ๊ฐ ์ง์ค๊ตญ์ ์ผ์์ ์์ ๊ฐ๋ฅ ์์ญ์ ์กฐ์ ํ ์ ์๋ค. ์ง์ค๊ตญ์ ์์ ๊ฐ๋ฅ ์์ญ์ ๊ณ ์๋๋ก ์์์ ์ฐ๊ฒฐ๋ ๊ตฌ๊ฐ์ผ๋ก ๋ํ๋๊ฒ ๋๋ค. N๊ฐ์ ์ผ์๊ฐ ์ ์ด๋ ํ๋์ ์ง์ค๊ตญ๊ณผ๋ ํต์ ์ด ๊ฐ๋ฅํด์ผ ํ๋ฉฐ, ์ง์ค๊ตญ์ ์ ์ง๋น ๋ฌธ์ ๋ก ์ธํด ๊ฐ ์ง์ค๊ตญ์ ์์ ๊ฐ๋ฅ ์์ญ์ ๊ธธ์ด์ ํฉ์ ์ต์ํํด์ผ ํ๋ค. ํธ์๋ฅผ ์ํด ๊ณ ์๋๋ก๋ ํ๋ฉด์์ ์ง์ ์ด๋ผ๊ณ ๊ฐ์ ํ๊ณ , ์ผ์๋ค์ ์ด ์ง์ ์์ ํ ๊ธฐ์ ์ธ ์์ ์ผ๋ก๋ถํฐ์ ์ ์ ๊ฑฐ๋ฆฌ์ ์์น์ ๋์ฌ ์๋ค๊ณ ํ์. ๋ฐ๋ผ์, ๊ฐ ์ผ์์ ์ขํ๋ ์ ์ ํ๋๋ก ํํ๋๋ค. ์ด ์ํฉ์์ ๊ฐ ์ง์ค๊ตญ์ ์์ ๊ฐ๋ฅ์์ญ์ ๊ฑฐ๋ฆฌ์ ํฉ์ ์ต์๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋จ, ์ง์ค๊ตญ์ ์์ ๊ฐ๋ฅ์์ญ์ ๊ธธ์ด๋ 0 ์ด์์ด๋ฉฐ ๋ชจ๋ ์ผ์์ ์ขํ๊ฐ ๋ค๋ฅผ ํ์๋ ์๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ผ์์ ๊ฐ์ N(1 โค N โค 10,000), ๋์งธ ์ค์ ์ง์ค๊ตญ์ ๊ฐ์ K(1 โค K โค 1000)๊ฐ ์ฃผ์ด์ง๋ค. ์ ์งธ ์ค์๋ N๊ฐ์ ์ผ์์ ์ขํ๊ฐ ํ ๊ฐ์ ์ ์๋ก N๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ์ขํ ์ฌ์ด์๋ ๋น ์นธ์ด ํ๋ย ์์ผ๋ฉฐ, ์ขํ์ ์ ๋๊ฐ์ 1,000,000 ์ดํ์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฌธ์ ์์ ์ค๋ช ํ ์ต๋ K๊ฐ์ ์ง์ค๊ตญ์ ์์ ๊ฐ๋ฅ ์์ญ์ ๊ธธ์ด์ ํฉ์ ์ต์๊ฐ์ ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
6
2
1 6 9 3 6 7
์ถ๋ ฅ
5
์์ 2
์ ๋ ฅ
10
5
20 3 14 6 7 8 18 10 12 15
์ถ๋ ฅ
7
My Sol A: DP
N = int(input())
K = int(input())
arr = sorted(list(map(int, input().split())))
dp = [[0]*N for _ in range(K)]
for j in range(1, N):
dp[0][j] = dp[0][j-1] + arr[j] - arr[j-1]
for i in range(1, K):
for j in range(i+1, N):
dp[i][j] = min(dp[i][j-1] + arr[j] - arr[j-1], dp[i-1][j-1])
print(dp[K-1][N-1])
DP๋ฅผ ์ฌ์ฉํ์ฌ ํ์๋ค.
- ๊ฐ๋ก๋ ์ผ์์ ์ธ๋ฑ์ค ์ธ๋ก๋ ์ค๊ณ๊ธฐ์ ๊ฐ์์ด๋ค.
- ์ด๋ค ํฌ์ธํธ์์ ์ค๊ณ๊ธฐ๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ค๊ณ๊ธฐ๋ฅผ ์ถ๊ฐํ์ง ์๋ ๊ฒฝ์ฐ๋ก ๋๋๋ค.
- ์ด๋ค ํฌ์ธํธ(
dp[i][j]
)์์ ์ต์ ํฌ๊ธฐ๋ ์ด์ ์ผ์๊น์ง์ ์ต์ ํฌ๊ธฐ์ ์ค๊ณ๊ธฐ๋ฅผ ํ๋ ๋ํ ๊ฒ(dp[i-1][j-1]
)๊ณผ ์ค๊ณ๊ธฐ๋ฅผ ์ถ๊ฐํ์ง ์๊ณ ์ด์ ์ผ์์์ ๊ฑฐ๋ฆฌ๋ฅผ ๋ํ๋ ๊ฒ(dp[i][j-1] + arr[j] - arr[j-1]
)์ด ์๋ค. - ์ด ๋ ์ค ๋ ์์ ๊ฐ์ ํฌ์ธํธ๋ก ์ ์ฅํ๊ณ ๋์ด๊ฐ๋ค.
- ์ด๋ ๊ฒ ๊ณ์ ํ๋ค๊ฐ
dp[K-1][N-1]
๋ฅผ ์ถ๋ ฅํ๋ฉด ๋๋ค.
๊ฒฐ๊ณผ
๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ
์๋ฌด๋๋ 2์ฐจ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ํฌ๊ณ , ๊ทธ ๊ฐ๊ฐ์ ๋ค์ด๊ฐ๋ ์๋ ํฌ๊ธฐ๊ฐ ์ปค์ ๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ๊ฐ ๋ฐ์ํ ๊ฒ ๊ฐ๋ค. ๊ทธ๋์ 2์ฐจ์ ๋ฐฐ์ด์ด์ง๋ง ํ์ 2๊ฐ๋ง ๋จ๊ธฐ๋ ๋ฐฉ์์ ํ์ฉํ๊ณ ์ ํ์๋ค.
My Sol B: deque
from collections import deque
N = int(input())
K = int(input())
arr = sorted(list(map(int, input().split())))
dp = [0]*N
for j in range(1, N):
dp[j] = dp[j-1] + arr[j] - arr[j-1]
Q = deque()
Q.append(dp)
for i in range(1, K):
Q.append([0]*N)
for j in range(i+1, N):
Q[1][j] = min(Q[1][j-1] + arr[j] - arr[j-1], Q[0][j-1])
Q.popleft()
print(Q[0][-1])
๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ต๋ํ ์ค์ด๊ธฐ ์ํด deque์ ํ์ 2๊ฐ๋ง ๋จ๊ธฐ๊ธฐ๋ก ํ๋ค. ์ด๋ deque์์ ํ์ popleftํ๋ฉด python์ GC๊ฐ ์ด ๋ฐ์ดํฐ์ ํด๋นํ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ๊ฑฐํด์ค๋ค๋ ๊ฒ์ด ์ ์ ๋ก ๊น๋ ค์ผ ํ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
import sys
input = sys.stdin.readline
n = int(input())
k = int(input())
sensor = list(map(int,input().split()))
sensor.sort()
array = []
for i in range(0,n-1):
array.append(sensor[i+1] - sensor[i])
array.sort()
print(sum(array[:n-k]))
์ด์ด๊ฐ ์์ ์ ๋๋ก ๊ฐ๋จํ ํ์ด์๋ค. N๊ฐ์ ์ผ์ ์ค K๊ฐ์ ๊ทธ๋ฃน์ผ๋ก ๋๋๊ฒ ๋๋๋ฐ, ์ด ํฌ๊ธฐ๋ฅผ ๊ฐ์ฅ ์ค์ด๋ ค๋ฉด ์ผ์๊ฐ ์ฌ์ด๊ฐ ๊ฐ์ฅ ํฐ ๊ฐ๊ฒฉ๋ค์ ๊ทธ๋ฃน์ ๊ฐ๊ฒฉ์ผ๋ก ๋์ด์ผ ํจ์ ์ ์ ์๋ค.
๋๋ฌธ์ K๊ฐ์ ์ง์ค๊ตญ์ (K-1)๊ฐ์ ๊ฐ๊ฒฉ์ ๊ฐ์ง๋ฏ๋ก ๊ฐ๊ฒฉ๋ค์ ํฌ๊ธฐ๊ฐ ํฐ ์์๋๋ก (K-1)๊ฐ๋ฅผ ๋นผ๋ด๋ฉด ๋๋ ๊ฒ์ด๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ