2442 Sequence 堆

Sequence

Time Limit: 6000MS		Memory Limit: 65536K
Total Submissions: 3721		Accepted: 1090

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

 

 

 

 

 

 

 

 

//

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[2005],b[4005],heap[2005],len;//堆    这道题最大元素在堆的顶部
void insert(int x)
{
    heap[++len]=x;//先插入
    int i=len;
    while(i>1&&x>heap[i/2])//再调整
    {
        heap[i]=heap[i/2];//较大元素上浮操作
        i/=2;
    }
    heap[i]=x;
}
void del()//删除堆顶最大元素
{
    int i=2,j=1;//j表示父节点，i表示子节点
    while(i<len)
    {
        i+=heap[i+1]>heap[i];//i表示heap[i+1]，heap[i]较大的元素的序号
        if(heap[len]>heap[i]) break;
        heap[j]=heap[i];//元素上浮
        j=i;
        i*=2;//往下延伸,继续上浮
    }
    heap[j]=heap[len--];//空缺一个，用最小的heap[len]补缺
}
int main()
{
    int ci,n,m;
    scanf("%d",&ci);
    while(ci--)
    {
        scanf("%d%d",&m,&n);
        len=0;//堆的元素个数
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            insert(a[i]);
        }
        for(int ci=2;ci<=m;ci++)
        {
            for(int i=1;i<=n;i++) scanf("%d",&b[i]);
            for(int i=1;i<=n;i++) //从1~是3100毫秒,从n~1是2891毫秒
            {
                a[i]=heap[1];//a[i]=当前堆最大元素
                del();//删除堆顶最大元素
            }
            len=0;//此时堆再次为空
            for(int i=1;i<=n;i++)
            {
                for(int j=1;j<=n;j++)
                {
                    if(len<n) insert(a[i]+b[j]);
                    else
                    {
                        if(a[i]+b[j]<heap[1])
                        {
                            del(); //已经有n个数了，这和这n个数中最大的数，
                            //即堆中第一个元素比较，如果比它小，则插入
                            insert(a[i]+b[j]);
                        }
                    }
                }
            }
        }
        //此时堆完成
        for(int i=n;i>=1;i--)
        {
            a[i]=heap[1];
            del();
        }
        printf("%d",a[1]);
        for(int i=2;i<=n;i++) printf(" %d",a[i]);printf("/n");
    }
    return 0;
}
/*
从第一组到第m组依次处理
首先第一组的n个数自然是最小的n个数，  然后这n个数和第二组的n个组进行组合，形成n×n个数，保留其前n个数，再处理第三组，依次类推直到第m组
为什么保留前n个数就可以了呢？   我们以第一组和第二组例所得的n×n个数为例，假设保留n+1个数，且这第n+1个数加上第三组的某个数x的和  在下一步中需要保留（即在下一步操作中属于前n小的数之一），然而前n个数中的任意一个数+x  < 第n+1个数+x  ，此时得出矛盾， 由此可知，每次处理后的n×n个数中只需保留前n个数即可
*/