聪明的木匠

题目

 
 

  
  一位老木匠需要将一根长的木棒切成N段。每段的长度分别为L1,L2,......,LN（1 <= L1,L2,…,LN <= 1000，且均为整数）个长度单位。我们认为切割时仅在整数点处切且没有木材损失。
 
 
 
 

  
  木匠发现，每一次切割花费的体力与该木棒的长度成正比，不妨设切割长度为1的木棒花费1单位体力。例如：若N=3，L1 = 3,L2 = 4,L3 = 5，则木棒原长为12，木匠可以有多种切法，如：先将12切成3+9.，花费12体力，再将9切成4+5，花费9体力，一共花费21体力；还可以先将12切成4+8，花费12体力，再将8切成3+5，花费8体力，一共花费20体力。显然，后者比前者更省体力。
 
 
 
 

  
  那么，木匠至少要花费多少体力才能完成切割任务呢？
 
 
 
 

  
  Input
 
 
第1行：1个整数N(2 <= N <= 50000)
第2 - N + 1行：每行1个整数Li(1 <= Li <= 1000)。
 
 

  
  Output
 
 
输出最小的体力消耗。
 
 

  
  Input 示例
 
 
3
3
4
5
 
 

  
  Output 示例
 
 
19

思路：

通过分析可以把木棒的分割过程用一个二叉树来代表。
叶子结点的值就是长度，叶子结点的权重就是其深度，耗费的体力就是叶子结点的带权值的和。
为了使耗费的体力最小，可以很容易的想到Huffman树。
 
结合具体题目情景，初始时每个长度为一个结点。
然后每次都挑选值最小的两个结点，组合成一个新的结点；如此重复，直至剩下一个结点，就是原木棒的长度。
然后计算所有叶子结点的带权值之和就是需要耗费的最少体力。
 
有了这个思路之后，我首先想的就是如何去构造一个Huffman树。但是仔细想了之后，这个题目不用保存完整的树结构，只需要借鉴Huffman树构造的思路。
具体方法如下：
1.     对所有的长度排序，体力值为0
2.     选出最小的两个长度，加入到体力值里
3.     把之前的最小的两个长度加到一起，组合成一个新的长度
4.     重新排序，回到第2步，直到只有1个长度值时停止
 
到这里之后还剩下一个关键的部分是排序。
第一次我是调用的c++ STL里的sort，发现时间耗费太长。
 
第二次，我手动写了一个插入排序，因为每次除了新构造的那个结点之外其他的结点都是有序的，这样把新节点依次与有序序列比较，应该很快就能找到正确的插入位置。不过看下面这个极端的情况：
1,1,1,1,1,…1，新结点是2，这样需要与所有的结点都比较一遍后才会找到合适的位置。这种情况下效率就会很差。
 
第三次，采用堆排序。小顶堆，每次取最顶上的两个，组成一个新的，然后从顶往下调整一遍有序。这种方法是效率最高的。
但是这里还是有一个问题，就是取两个组合成一个，这种方法相当于删除了堆顶。通常删除堆顶，只需要把最后一个元素放在堆顶然后重新从上往下调整一遍即可。但是这里除了删除堆顶之外，还更新了一个结点元素所以跟这种情况不完全一样。
后来我进一步简化，觉得不用每次都用堆排序将整个序列弄得完全有序，只需要用小顶堆，每次快速得找到最小的一个元素即可。

代码：
#include <iostream>
#include <algorithm>

using namespace std;

void MinHeapFixdown(int a[],int i,int n)
{
	int j,temp;

	temp = a[i];
	j = 2*i + 1;
	while (j < n) {
		if (j+1 < n && a[j+1] < a[j])
			j++;
		if (a[j] >= temp)
			break;
		a[i] = a[j];
		i = j;
		j = 2*i +1;
	}
	a[i] = temp;
}

void MakeMinHeap(int a[],int n)
{
	for(int i = n/2 -1; i >= 0; i--) {
		MinHeapFixdown(a,i,n);
	}
}

int main()
{
	int size;
	int i;
	int sum = 0;
	int A[50000];
	int first;
	cin >> size;
	for (i = 0; i < size; i++)    
		cin >> A[i];
	MakeMinHeap(A,size);
	for (i = size-1; i >=1; i--) {
		sum += A[0];
		first = A[0];
		A[0] = A[i];
		MinHeapFixdown(A,0,i);
		sum += A[0];
		A[0] += first;
		MinHeapFixdown(A,0,i);
	}
	cout << sum;
	return 0;
}
题外话：
Huffman也是一种贪心算法
贪心算法得到的只是局部最优，运用贪心需要证明得到的结果是全局最优，一般用得比较多的就是反证法。