貪欲法と優先度付きキュー

import heapq n = int(input())piles = list(map(int, input().split()))heapq.heapify(piles)  # 가장 작은 값이 언제나 맨 앞(piles[0])에 오게 한다 total = 0while len(piles) > 1:    a = heapq.heappop(piles)  # 가장 작은 두 묶음을 꺼낸다    b = heapq.heappop(piles)    cost = a + b    print(cost)    total += cost    heapq.heappush(piles, cost)  # 합친 묶음을 다시 넣는다print(total)

// 내장 우선순위 큐가 없다. 이만한 크기에서는 가장 작은 값을 직접 찾아 꺼내도 된다function popMin(list) {  let at = 0;  for (let i = 1; i < list.length; i++) if (list[i] < list[at]) at = i;  return list.splice(at, 1)[0];} const t = require("fs").readFileSync(0, "utf8").trim().split(/\s+/).map(Number);const n = t[0];const piles = t.slice(1, 1 + n); let total = 0;while (piles.length > 1) {  const a = popMin(piles); // 가장 작은 두 묶음을 꺼낸다  const b = popMin(piles);  const cost = a + b;  console.log(cost);  total += cost;  piles.push(cost); // 합친 묶음을 다시 넣는다}console.log(total);

import { readFileSync } from "node:fs"; // 내장 우선순위 큐가 없다. 이만한 크기에서는 가장 작은 값을 직접 찾아 꺼내도 된다function popMin(list: number[]): number {  let at = 0;  for (let i = 1; i < list.length; i++) if (list[i] < list[at]) at = i;  return list.splice(at, 1)[0];} const t: number[] = readFileSync(0, "utf8").trim().split(/\s+/).map(Number);const n: number = t[0];const piles: number[] = t.slice(1, 1 + n); let total = 0;while (piles.length > 1) {  const a = popMin(piles); // 가장 작은 두 묶음을 꺼낸다  const b = popMin(piles);  const cost = a + b;  console.log(cost);  total += cost;  piles.push(cost); // 합친 묶음을 다시 넣는다}console.log(total);

import java.util.PriorityQueue;import java.util.Scanner; public class Main {    public static void main(String[] args) {        Scanner in = new Scanner(System.in);        int n = in.nextInt();        PriorityQueue<Integer> piles = new PriorityQueue<>(); // 꺼내면 언제나 가장 작은 값이 나온다        for (int i = 0; i < n; i++) piles.add(in.nextInt());         int total = 0;        while (piles.size() > 1) {            int a = piles.poll(); // 가장 작은 두 묶음을 꺼낸다            int b = piles.poll();            int cost = a + b;            System.out.println(cost);            total += cost;            piles.add(cost); // 합친 묶음을 다시 넣는다        }        System.out.println(total);    }}

using System;using System.Collections.Generic; class Program{    static void Main()    {        int n = int.Parse(Console.ReadLine());        // (값, 우선순위) 짝으로 넣고, 우선순위가 가장 작은 것부터 나온다        PriorityQueue<int, int> piles = new PriorityQueue<int, int>();        foreach (string w in Console.ReadLine().Split()) piles.Enqueue(int.Parse(w), int.Parse(w));         int total = 0;        while (piles.Count > 1)        {            int a = piles.Dequeue(); // 가장 작은 두 묶음을 꺼낸다            int b = piles.Dequeue();            int cost = a + b;            Console.WriteLine(cost);            total += cost;            piles.Enqueue(cost, cost); // 합친 묶음을 다시 넣는다        }        Console.WriteLine(total);    }}

#include <functional>#include <iostream>#include <queue>#include <vector> int main() {    int n;    std::cin >> n;    // std::greater를 줘야 가장 작은 값이 먼저 나온다(기본은 가장 큰 값)    std::priority_queue<int, std::vector<int>, std::greater<int>> piles;    for (int i = 0; i < n; i++) {        int x;        std::cin >> x;        piles.push(x);    }     int total = 0;    while (piles.size() > 1) {        int a = piles.top(); // 가장 작은 두 묶음을 꺼낸다        piles.pop();        int b = piles.top();        piles.pop();        int cost = a + b;        std::cout << cost << '\n';        total += cost;        piles.push(cost); // 합친 묶음을 다시 넣는다    }    std::cout << total << '\n';}

#include <stdio.h> int piles[1000];int count; // 내장 우선순위 큐가 없다. 이만한 크기에서는 가장 작은 값을 직접 찾아 꺼내도 된다int popMin(void) {    int at = 0;    for (int i = 1; i < count; i++) if (piles[i] < piles[at]) at = i;    int v = piles[at];    piles[at] = piles[--count]; // 빈자리는 맨 끝 값으로 메운다    return v;} int main(void) {    int n;    scanf("%d", &n);    for (int i = 0; i < n; i++) scanf("%d", &piles[i]);    count = n;     int total = 0;    while (count > 1) {        int a = popMin(); // 가장 작은 두 묶음을 꺼낸다        int b = popMin();        int cost = a + b;        printf("%d\n", cost);        total += cost;        piles[count++] = cost; // 합친 묶음을 다시 넣는다    }    printf("%d\n", total);    return 0;}

// 내장 우선순위 큐가 없다. 이만한 크기에서는 가장 작은 값을 직접 찾아 꺼내도 된다popMin(list){    at = 0;    繰り返す (i = 1; i < list.個数; i++)    {        もし (list[i] < list[at])        {            at = i;        }    }    v = list[at];    list.位置で取り除く(at);    返す v;} n = コンソール.行読み().数に();piles = コンソール.数読み(); total = 0;間 (piles.個数 > 1){    a = popMin(piles); // 가장 작은 두 묶음을 꺼낸다    b = popMin(piles);    cost = a + b;    コンソール.書く(cost);    total += cost;    piles.追加(cost); // 합친 묶음을 다시 넣는다}コンソール.書く(total);