[ACM] POJ 2442 Sequence (堆的性质）

Sequence

Time Limit: 6000MS		Memory Limit: 65536K
Total Submissions: 7011		Accepted: 2262

Description

Given m sequences, each contains n non-negative integer. Now we may select one number from each sequence to form a sequence with m integers. It's clear that we may get n ^ m this kind of sequences. Then we can calculate the sum of numbers in each sequence, and get n ^ m values. What we need is the smallest n sums. Could you help us?

Input

The first line is an integer T, which shows the number of test cases, and then T test cases follow. The first line of each case contains two integers m, n (0 < m <= 100, 0 < n <= 2000). The following m lines indicate the m sequence respectively. No integer in the sequence is greater than 10000.

Output

For each test case, print a line with the smallest n sums in increasing order, which is separated by a space.

Sample Input

1
2 3
1 2 3
2 2 3

Sample Output

3 3 4

Source

POJ Monthly,Guang Lin

解题思路：

        有m行，每行n个数，从每行中取出一个数相加一起求出sum，这样的sum有n的m次方个。要求的前n个最小的sum值。

第一次使用STL里面的堆，一开始对pop_heap()有点不太理解，后来明白了，比如对数组heap[n]，最大下标为n-1建堆，默认的是建立大顶堆，heap[0]是数组中最大的数，写一条pop_heap()语句，就是把heap[0]和 heap[n-1]互换，然后重新对 heap[0]到heap[n-2] （除去最后一个元素）重新建堆，heap[0]依然是最大值，这样相当于更新最大值的操作。

        对于本题，堆的性质可以很好的运用。 三个数组old[n] , new [n] , heap[n]，old[]是用来保存前i行元素每行取出一个元素加起来所得的前n个最小sum，new[n]是第i+1行的输入元素，heap[n]是中间数组，用来建堆，并更新其最大值元素，每处理完第i行，获得前i行的前n个最小sum（这时保存在heap[]里面），就把heap[]元素赋给old[]，这样前m行都处理完毕后，再对old[]数组从小到大排一次序，输出即为所求了。

下面具体说一下heap[]的作用。

         一开始把第一行的元素赋给old[], 并对其排序，然后将第一行的元素都加上第二行排序后的第一个元素，把n个值放到heap[]里面，这样就获得了一个临时的前两行的前n个sum值，但这并不一定是前两行最小的前n个sum值  ，因为第二行也有n个元素，得枚举出所有情况（即第二行的第二个，第三个...元素分别与第一行的所有值相加获得sum值）要在这些所有的情况里面取最小的前n个，这就要发挥堆的作用了，前面说临时的前n个sum值保存在heap[]里面了，然后对heap[]进行建堆make_heap(heap,heap+n);默认大顶堆，即heap[0]是最大值，在枚举的时候如果有发现求出的一个临时sum值（temp)比heap[ 0 ]要小，那就需要对heap[0]更新，因为我们是要求前n个最小的sum值，用 pop_heap(heap,heap+n);把最大值heap[0]与heap[n-1]互换，然后另heap[n-1] = temp；这样heap[]最大值就更新了（原来的最大值从数组中去除），但不知道是数组中的哪一个值，push_heap(heap,heap+n);  对其重新建堆，这样heap里面的最大的就是heap[0] 了。枚举完，更新完就把前两行的前n个最小的sum值求出来了，剩下的行是相同的操作。 上面的排序是为了减少不必要的操作，在枚举时可以提前退出，这就和 排序好的 2,4,5,6我们要最小的值，那就取2，不用考虑后面的数了一样。

代码：

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=2010;
int Old[maxn],New[maxn],heap[maxn];

int main()
{
    int t;cin>>t;
    int m,n;
    while(t--)
    {
        cin>>m>>n;
        for(int i=0;i<n;i++)
            cin>>Old[i];
        sort(Old,Old+n);
        m--;
        while(m--)
        {
            for(int i=0;i<n;i++)
                cin>>New[i];
            sort(New,New+n);
            for(int i=0;i<n;i++)
                heap[i]=Old[i]+New[0];
            make_heap(heap,heap+n);//建立大顶堆，heap[0]是最大的值

            //通过枚举把heap里面的大值都换掉，每次换的都是当前的最大值
            for(int i=1;i<n;i++)//新数据的剩下的值
            {
                bool ok=0;
                for(int j=0;j<n;j++)//旧数组
                {
                    int temp=New[i]+Old[j];
                    if(temp<heap[0])
                    {
                        pop_heap(heap,heap+n);//heap数组里面的最后一个元素和第一个元素（最大值）互换，并把除最后一个元素以外的元素重新建堆
                        heap[n-1]=temp;
                        push_heap(heap,heap+n);
                        ok=1;//可以更新最大值
                    }
                    else //当旧数组的第j个数和新数组的数第i个数相加已经没有比大值还小的了，就不用再继续加旧数组了，因为旧数组是排好序的，再加也会比heap里面的最大值大
                        break;
                }
                if(!ok)//如果新数据的第i个数分别和旧数组的n个数相加都没有更新heap[]里面的最大值，那么第i+1个数肯定也不会更新，因为排好序
                    break;
            }
            for(int i=0;i<n;i++)
                Old[i]=heap[i];
            sort(Old,Old+n);
        }
        for(int i=0;i<n-1;i++)
            cout<<Old[i]<<" ";
        cout<<Old[n-1]<<endl;
    }
    return 0;
}

下面贴一下堆的知识：http://blog.csdn.net/hnust_xiehonghao/article/details/9172875转载

最大堆最小堆代码实现

http://blog.csdn.net/xiaoxiaoxuewen/article/details/7570621

最大堆 最小堆原理图

http://www.cnblogs.com/wu8685/archive/2010/12/30/1922218.html 

STL 的堆操作

http://hi.baidu.com/solofancy/item/14acd02b9743f7d30f37f927  

http://blog.csdn.net/morewindows/article/details/6967409 

STL 的堆操作  来自上面的博客  

STL里面的堆操作一般用到的只有4个:make_heap();、pop_heap();、push_heap();、sort_heap(); 
他们的头文件函数是#include <algorithm>

首先是make_heap(); 
他的函数原型是：void make_heap(first_pointer,end_pointer,compare_function); 
一个参数是数组或向量的头指针，第二个向量是尾指针。第三个参数是比较函数的名字。在缺省的时候，默认是大跟堆。（下面的参数都一样就不解释了） 
作用：把这一段的数组或向量做成一个堆的结构。范围是(first,last) 

然后是pop_heap(); 

它的函数原型是：void pop_heap(first_pointer,end_pointer,compare_function); 

作用：pop_heap()不是真的把最大（最小）的元素从堆中弹出来。而是重新排序堆。它 
把first和last交换，然后将[first,last-1)的数据再做成一个堆。 

接着是push_heap() void pushheap(first_pointer,end_pointer,compare_function); 

作用：push_heap()假设由[first,last-1)是一个有效的堆，然后，再把堆中的新元素加
进来，做成一个堆。 

最后是sort_heap()void sort_heap(first_pointer,end_pointer,compare_function);

作用是sort_heap对[first,last)中的序列进行排序。它假设这个序列是有效堆。（当然 
，经过排序之后就不是一个有效堆了）

实例：

#include<algorithm>
#include<cstdio>
using namespace std;
bool cmp(int a,int b)
{
  return a>b;
}
int main()
{
  int i,number[20]={29,23,20,22,17,15,26,51,19,12,35,40};	
  make_heap(&number[0],&number[12]);	
  //结果是:51 35 40 23 29 20 26 22 19 12 17 15	
  for(i=0;i<12;i++)		
    printf("%d ",number[i]);
  printf("\n");	
  make_heap(&number[0],&number[12],cmp);
  //结果：12 17 15 19 23 20 26 51 22 29 35 40
  for(i=0;i<12;i++)		
    printf("%d ",number[i]);	
  printf("\n");	
  //加入元素8	
  number[12]=8;	
  //加入后调整	
  push_heap(&number[0],&number[13],cmp);	
  //结果：8 17 12 19 23 15 26 51 22 35 40 20	
  for(i=0;i<13;i++)		
    printf("%d ",number[i]);	
  printf("\n");	
  //弹出元素8	
  pop_heap(&number[0],&number[13],cmp);	
  //结果：12 17 15 19 23 20 26 51 22 29 35 40	
  for(i=0;i<13;i++)		
    printf("%d ",number[i]);	
  printf("\n");	
  sort_heap(&number[0],&number[12],cmp);	
  //结果不用说都知道是有序的了！	
  for(i=0;i<12;i++)		
    printf("%d ",number[i]);	
  return 0;	
}