15-alstjr7437

[alstjr7437]

🔗 문제 링크

파일 합치기3

✔️ 소요된 시간

30분

💡 문제 이해

일단 문제를 이해하자면

1. 각 파일을 하나씩 들고온다(a,b)
2. 들고온 파일을 합친다(c = a+b)
3. 한개가 될때까지 쭉 합친다.
4. 지금까지 나왔던 c와 하나가 된 파일의 총합을 계산한다.

그래서 문제가
40 30 30 50 이 들어오면
40 + 30 = 70 -> 70 30 50
70 + 30 = 100 -> 100 50
100 + 50 = 150 -> 150
70 + 100 + 150 = 320으로 됩니다.

그 중 제일 작은 총합을 계산하는거니까
위에 부분은 그냥 2개를 더하고 하나씩 추가해서 더하는 경우였고 제일 작은 경우의 수로 가려면
생각한 부분이 정렬을 한 후에 작은 수를 2개씩 더하면 제일 작은 경우가 됐습니다.


30 30 40 50
30 + 30 = 60 -> 60 40 50
40 + 50 = 90 -> 60 90
60 + 90 = 150 -> 150
60 + 90 + 150 = 300

✨ 수도 코드

위와 같이 생각했고 그래서 나온 수도 코드는

1. heap에 숫자를 모두 push한다.
2. heap에 pop을 두번하여서 제일 작은 수 2개를 가지고 온다.
3. 두개의 수를 더한다.
   3-1. 3에 나온 수를 결과에 더한다. (결과(c)를 총합(answer)에 넣기
   3-2. 3에 나온 수를 다시 heap에 push한다.(30 + 30 = 60) 60을 heap에 넣기 -> 60, 40, 50
4. heap이 하나가 될때까지 반복한다.

코드

from heapq import *

t = int(input())

for _ in range(t):
    n = int(input()) 
    answer = 0
    heap = []

    for i in map(int, input().split()):
        heappush(heap, i)
    
    while len(heap) > 1 :
        temp = 0
        temp += heappop(heap) + heappop(heap)
        heappush(heap, temp)
        answer += temp
    print(answer)

📚 새롭게 알게된 내용

heap을 까먹었었는데 오래만에 다시 쓰려니까 개념을 다시 공부하면서 했는데 좋았습니다!

[9kyo-hwang]

이렇게 하나씩 넣을 필요 없이

heap = list(map(int, input().split()))
heapify(heap)

일반 리스트에 저장하고 heapify를 수행해주면 힙 구조로 한 번에 바꿔줍니다. 더 줄이자면

heapify(heap := list(map(int, input().split())))

이렇게도 되구요.

[alstjr7437]

아하 사실 heap을 다시 공부하면서 heapify를 봤었는데
그냥 힙구조로 바꿔주는데 list를 만들어두고 다시 heap으로 바꾸면 시간 문제가 생길까봐 그랬습니다!!
혹시 따로 시간에 관련된 부분은 없을까요?

[9kyo-hwang]

heap을 구성하는 데는 Sift up 방식과 Sift down 방식이 존재합니다.

sift up 방식은 heappush 과정에서 발견할 수 있는 구조로, 주어진 노드의 부모 노드와 비교해 heap property 만족시키거나, 그렇지 않으면 root에 도착할 때 까지 swap하는 방법을 뜻합니다.
sift down 방식은 heappop 과정에서 발견할 수 있는 구조로, 주어진 노드의 자식 노드 중 key가 큰 값(or 작은 값)과 비교해 heap property를 만족하거나, 그렇지 않으면 leaf에 도착할 때 까지 swap 하는 과정을 뜻합니다.

sift up은 leaf -> root까지 가는 과정이고 sift down은 internal -> leaf까지의 과정입니다.
둘 다 단일 요소에 대해서 연산을 수행할 경우 시간복잡도는 $O(log N)$이나, 완전이진트리 구조를 갖는 힙의 특성때문에 전체 요소에 대해 heap을 구성하는 시간은 Sift up의 경우 $O(NlogN)$이고 Sift down의 경우 $O(N)$ 입니다.

그리고 파이썬의 heapify는 Sift down 방식으로 구현되어 있습니다. 따라서 heappush로 일일이 요소를 집어넣는 것보다, 하나의 리스트를 heapify를 통해 힙으로 만드는 것이 더 효율적입니다.

Build Heap 시간복잡도 이해하기, Heap 자료구조 이 게시글을 참고해보세요.

[9kyo-hwang]

temp = heappop(heap) + heappop(heap)

왜 바로 할당 안하셨죠

[alstjr7437]

어머.. 실수를..

[fnzksxl]

오 ㅋㅋ 이거 deque로 정렬때려서 왼쪽에서 두개 뽑아도 되려나? 하고

from collections import deque
import sys

input = sys.stdin.readline

T = int(input())

for _ in range(T):
  N = int(input())
  files = deque(map(int, input().split()))
  cost = 0
  while len(files) > 1:
    files = deque(sorted(files))
    file1 = files.popleft()
    file2 = files.popleft()
    cur_cost = file1 + file2
    
    cost += cur_cost
    files.append(cur_cost)
  
  print(cost)

이렇게 해봤는데 역시 시간초과가 뜨네요. 힙을 씁시다!

[SeongHoonC]

처음에 실패하길래 왜그런가 했더니 범위 1,000,000 이 10000 개 더해지면 10억이라 범위를 넘어가더라구요. 그래서 Long 으로 바꿨더니 통과했숨다.

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.PriorityQueue

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val t = br.readLine().toInt()
    repeat(t) {
        val n = br.readLine().toInt()
        val line = br.readLine().split(" ").map { it.toLong() }
        val pq = PriorityQueue<Long>().apply { addAll(line) }
        var cost: Long = 0L

        // 파일이 하나가 되면 끝
        while (pq.size > 1) {
            val sum = pq.poll() + pq.poll()
            cost += sum
            pq.add(sum)
        }
        println(cost)
    }
}

[wkdghdwns199]

우선순위 큐 쓰는 법 잘 볼 수 있어서 좋았던 거 같아요! 민석 님 코드 보고 참고해서 다시 한 번 풀어봤습니당~

import sys 
from heapq import *
input = sys.stdin.readline
T = int(input())
for _ in range(T):
    N = int(input())
    chapters = list(map(int, input().split()))
    time_list = []
    min_time=0
    for chapter in chapters :
        heappush(time_list, chapter)
    while len(time_list) > 1 :
        temp =0 
        temp += heappop(time_list) + heappop(time_list)
        heappush(time_list, temp)
        min_time += temp
    print(min_time)