NOIp 2004 合并果子

题目描述

        在一个果园里，多多已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。多多决定把所有的果子合成一堆。          每一次合并，多多可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。可以看出，所有的果子经过n-1次合并之后，就只剩下一堆了。多多在合并果子时总共消耗的体力等于每次合并所耗体力之和。          因为还要花大力气把这些果子搬回家，所以多多在合并果子时要尽可能地节省体力。假定每个果子重量都为1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使多多耗费的体力最少，并输出这个最小的体力耗费值。          例如有3种果子，数目依次为1，2，9。可以先将1、2堆合并，新堆数目为3，耗费体力为3。接着，将新堆与原先的第三堆合并，又得到新的堆，数目为12，耗费体力为12。所以多多总共耗费体力=3+12=15。可以证明15为最小的体力耗费值。

输入

        输入文件fruit.in包括两行，第一行是一个整数n(1< ＝n< =10000)，表示果子的种类数。第二行包含n个整数，用空格分隔，第i个整数ai(1< ＝ai< =20000)是第i种果子的数目。

输出

        输出文件fruit.out包括一行，这一行只包含一个整数，也就是最小的体力耗费值。输入数据保证这个值小于2^31。

样例输入

3 1 2 9

样例输出

15

提示

 对于30％的数据，保证有n< =1000；

 对于50％的数据，保证有n< =5000； 

 对于全部的数据，保证有n< =10000。

这题显然是用贪心，每次找的最小的两堆，合并，再找最小的两堆。这题如果纯模拟的话复杂度为O(n^2*logn) ,显然会超，这时我们会用到一个叫堆的数据结构，（此题中就是哈夫曼树），将n堆果子初始化为小根堆，每次找出最小的两个并维护小根堆的性质即可，复杂度降为O(nlogn)。

#include<cmath>
#include<vector>
#include<cstdio>
#include<string>
#include<cstdlib>
#include<cstring>
#include<memory.h>
#include<iostream>
#include<algorithm>
#define MAXN 10100
using namespace std;
int n;
long long Ans = 0;
int heap[MAXN],size = 0;

void Adjust(int k,int len){
	int left_node = 2*k, right_node = 2*k+1, root = k;
	 if (root <= len/2){
		if (left_node <= len && heap[left_node] < heap[root]) root = left_node;
		if (right_node <= len && heap[right_node] < heap[root]) root = right_node;
		//找出当前节点最小的，如果根节点就是最小的，不必再往下找
			if (root != k) {
			swap(heap[k],heap[root]);
			Adjust(root,len);//维护以交换的结点为根的子堆
		}
    }
}
void HeapWork(int len){
    int Root;
	for (int i=len;i>=2;i--) {
        Root = heap[1];//取出跟（最小的一堆）
        heap[1] = heap[i];
 		Adjust(1,i-1);//重新调整，找到第二小的
 		heap[1] += Root;//将最小的两堆合并，加入堆
 		Ans += heap[1];
 		Adjust(1,i-1);//维护小根堆
	}
}
int main(){
	cin >> n;
    for (int i=1;i<=n;i++) scanf("%d",&heap[i]);
    sort(heap+1,heap+n+1);
    //初始化：读入后先排序预处理，建立小根堆。
    HeapWork(n);//合并果子
    cout << Ans ;
    return 0;
}

这题贪心证明如下：

首先，假设合并之后只是把两堆搬到一起，不合并
那么，合并x，y堆所消耗的体力就是组成x的堆的果子数+组成y堆的果子数
这样，假设某一堆t，被某一个堆合并，又被某一个堆合并...重复m次
那么单单考虑这个t堆，它所需要消耗的体力将会是m*果子数(t)
这样的话，合并的总代价相当于：m(1)*果子数(1) +m(2)*果子数(2) +...+m(n)*果子数(n) 
而果子数是一定的，m(1)+m(2)+...+m(n)的总和是一定的（因为总合并次数一定），所以我们只需要使果子数大的那一堆的m尽量小，使果子数小的那一堆的m尽量大
一种简单的策略就是每次取两个最小的堆，合并。

这样可以使果子数小的堆多次合成，果子数大的堆少合成
就取到了最优值。

--------------------------------------------------------------------------------------------------------------------------------------------------------------

我发现某大神更精练的写法。。。

#include <iostream>
#include <cstring>
using namespace std;
int heap[30001],size=0;
void put(int n)
{
	heap[++size]=n;
	int now=size;
	while(now>1){
		int next=now/2;
		if(heap[now]>=heap[next])return;
		swap(heap[next],heap[now]);
		now=next;
	}
}
int get()
{
    int res=heap[1];
    heap[1]=heap[size--];
    int now=1;
    while(now<=size/2){
		int next=now*2;
		if(next<size&&heap[next+1]<heap[next])next++;
		if(heap[next]>=heap[now])return res;
		swap(heap[next],heap[now]);
		now=next;
    }
    return res;
}
int main()
{
    int n,x,y,ans=0;
    cin>>n;
    for(int i=1;i<=n;i++){cin>>x;put(x);}
    for(int i=1;i<n;i++){
		x=get(); y=get();
		put(x+y);
		ans+=x+y;
	}
	cout<<ans;
	return 0;
}