[Daimayuan] 切割（C++，贪心，哈夫曼树）

题目描述

有一个长度为 $\sum a_i$ 的木板，需要切割成 $n$ 段，每段木板的长度分别为 $a_1,a_2,\dots ,a_n$。

每次切割，会产生大小为被切割木板长度的开销。

请你求出将此木板切割成如上 $n$ 段的最小开销。

输入格式

第 $1$ 行一个正整数表示 $n$。

第 $2$ 行包含 $n$ 个正整数，即 $a_1,a_2,\dots ,a_n$。

输出格式

输出一个正整数，表示最小开销。

样例输入

5
5 3 4 4 4

样例输出

47

数据范围

对于全部测试数据，满足 $1\le n,a_i\le 10^5$。

附加说明

原题：[NOIP2004 提高组] 合并果子 / [USACO06NOV] Fence Repair G

需要 O(n) 解法的 数据加强版（$1\le n\le 10^7$）

解题思路

首先我们采用逆向思维，改变题意为：

把$n$块长度分别为 $a_1,a_2,\dots ,a_n$的木板合并成一块，每次合并只能操作两块，会产生合并后木板长度的开销。

可以很容易发现这和题意描述是一样的。

然后引入核心思路：哈夫曼树。

哈夫曼树常用于数据压缩（本质上是编码方式），基本思想就是：

统计文本中的所有符号的词频，每次选择词频最低的两个进行操作，将它们连到一个新的父节点上，然后将父节点赋值为二者词频之和，直到生成一棵树。

这种方式能够保证词频越小的节点深度越深（编码长度越长），词频越高的节点深度越浅（编码长度越短），也就完成了数据压缩。

那么这和本题有什么关系？

我们可以认为哈夫曼树中的叶子节点就是$n$块木板，节点深度就是木板被操作的次数。

（注：我们可以把合并后的木板仍然看成是多块木板，只不过这几块木板可以一起操作。）

所以，深度越深也就代表着这块木板被操作的次数越多，深度越浅也就代表着这块木板被操作的次数越少。

故哈夫曼树算法能够保证最小开销。

代码实现：

采用优先队列维护木板，每次取出两块进行合并，然后将合并后的木板插入队列。

AC代码如下：

（前排提示：/* 十年OI一场空，不开long long见祖宗 */）

#include <iostream>
#include <queue>
using namespace std;
const int max_n = 1e5;
const int max_a = 1e5;

priority_queue<long long, vector<long long>, greater<long long>>pq;

int main() {
	long long n, temp;
	cin >> n;
	for (int i = 0; i < n; i++) {
		cin >> temp;
		pq.push(temp);
	}

	long long ans = 0;
	while (pq.size() > 1) {
		long long b1 = pq.top(); pq.pop();
		long long b2 = pq.top(); pq.pop();
		pq.push(b1 + b2);
		ans += (long long)(b1) + (long long)(b2);
	}
	cout << ans << endl;
	return 0;
}

后排推一下我写的合并果子$qwq$

然后是数据加强版合并果子：

贪心算法是不能优化的了，可以优化的地方在于优先队列。

因为我们每次将合并后的果堆插入队列中，队列都会运行排序算法找到应该插入的位置。

优化的前提是这样的：

每次合并后的果堆一定不会比上一次合并得到的果堆小。

那么我们就不需要将其插入优先队列，只需要另外维护一个队列用来存储合并后的果堆，然后每次取出两个队列中队首比较小的一个即可。

直观的思路是这样的：

首先采用比快速排序更快的排序算法桶排序，将果堆维护在一个有序队列中；

然后再维护一个队列用于存储合并后的果堆；

最后运行的贪心算法与之前一致。

AC代码如下：

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
using namespace std;
const int max_a = 1e5;

queue<long long>q1, q2;
int buckets[max_a + 1];

int main() {
	int n, temp;
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		scanf("%d", &temp);
		buckets[temp]++;
	}

	for (int i = 1; i <= max_a; i++) {
		while (buckets[i]--) {
			q1.push((long long)(i));
		}
	}

	long long t1, t2, ans = 0;
	for (int i = 1; i < n; i++) {
		if (q2.empty() || !q1.empty() && q1.front() < q2.front()) {
			t1 = q1.front();
			q1.pop();
		}
		else {
			t1 = q2.front();
			q2.pop();
		}

		if (q2.empty() || !q1.empty() && q1.front() < q2.front()) {
			t2 = q1.front();
			q1.pop();
		}
		else {
			t2 = q2.front();
			q2.pop();
		}

		q2.push(t1 + t2);
		ans += t1 + t2;
	}

	cout << ans << endl;
	return 0;
}

其实这段代码还会$T$，怎么优化？当然是用无敌的快读了：

void read(int& x) {
    x = 0;
    char c = getchar();
    while ('0' <= c && c <= '9') {
        x = x * 10 + c - '0';
    	c = getchar();
    }
}