题目链接：http://poj.org/problem?id=2442
Time Limit: 6000MS Memory Limit: 65536K
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
题意：
给出 $m$ 个长度为 $n$ 的序列，在每一个序列中挑选一个数求和，可知有 $n^m$ 个结果，要求给出这些结果中前 $n$ 小的。
题解（参考《算法竞赛进阶指南》）：
首先考虑当 $M=2$ 时的做法，记这两个序列为 $a,b$，先对所有的序列进行升序排序，并且用两个指针 $p,q$ 分别指向这两个序列的头部 $a[0],b[0]$，显然此时就是第 $1$ 小的和 $S_1 = a[0] + b[0]$。
那么，第 $2$ 小的和 $S_2 = \min (a[1] + b[0], a[0] + b[1])$，
如果第 $2$ 小和是 $S_2 = a[1] + b[0]$，那么此时竞争的第 $3$ 小的候选者，除了上面已经存在的 $a[0] + b[1]$ 外还应当再增加 $a[2] + b[0], a[1] + b[1]$，也就是序列一的指针 $ptr_1++$ 或者序列二的指针 $ptr_2++$。
不难想到，可以用一个小顶堆（或者STL的优先队列）来维护所有候选者，不断地扔进去新晋的候选者，再取出堆顶作为答案之一，再由该堆顶求出新的候选者插入堆中，再取出堆顶，反复如此……
候选方案产生方式如图：
![POJ 2442 - Sequence - [小顶堆][优先队列]_子节点](https://s2.51cto.com/images/blog/202108/14/44b862d0ca09209a4ab63cddb0b5a910.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=/resize,m_fixed,w_1184)
不过，有一点需要注意，例如我们在上述例子中已得 $S_2 = a[1] + b[0]$，那么入堆两个新的候选者之后堆中有三个节点： $a[0] + b[1], a[2] + b[0], a[1] + b[1]$；此时如果 $S_3 = a[0] + b[1]$，会发现又一次产生了候选者 $a[1] + b[1]$，这样就产生了重复，具体表现就是在上图中，就是绝大部分候选方案从 $(0,0)$ 出发可以有多条路径到达。重复方案多次入堆显然是影响正确性的，因此要避免这种情况发生。
不妨增加限定，如果当前选中的方案所产生新的候选者是 $ptr_2++$，那么以后都只能 $ptr_2++$，不能再回到 $ptr_1++$。换句话说，$a[0]+b[0]$ 要走到任何候选方案 $a[i]+a[j]$，必须先移动 $ptr_1 = 0 \sim i$，再移动 $ptr_2 = 0 \sim j$，使得到达备选方案 $a[i]+a[j]$ 的路径的唯一性，这样即可避免产生同一个候选方案重复入队的情况。
增加限定条件后的候选方案产生方式如图（不难看出，已经变为了一棵树）：
![POJ 2442 - Sequence - [小顶堆][优先队列]_#include_02](https://s2.51cto.com/images/blog/202108/14/4df1a6d0301e50963947c939e27b7d5b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_30,g_se,x_10,y_10,shadow_20,type_ZmFuZ3poZW5naGVpdGk=/resize,m_fixed,w_1184)
考虑到添加了该限定条件后，是否影响到算法的正确性：
考虑原算法在选定 $a[i] + b[j]$ 成为第 $k$ 小之后，原本会产生 $a[i+1] + b[j]$ 和 $a[i] + b[j+1]$ 两个新的候选者。那么增加限定条件后，是否会发生本来第 $k+1$ 小应当是 $a[i+1] + b[j]$ 但是现在却没有生成该候选方案的情况？
根据限定条件，可知 $a[i] + b[j]$ 该方案成为第 $k$ 小，必然是由于 $a[i] + b[j-1]$ 产生了它，往前依次类推必然是在某一时刻选择了 $a[i] + b[0]$，而 $a[i] + b[0]$ 会产生两个候选者 $a[i+1] + b[0]$ 和 $a[i] + b[1]$，由此可知选中方案 $a[i] + b[j]$，只要 $j \ge 1$，那么此时队列里必然曾经出现过 $a[i+1] + b[0]$。
因此，如果说选定 $a[i] + b[j]$ 成为第 $k$ 小同时堆中没有 $a[i+1] + b[j]$，那么此时堆中必然存在 $a[i+1] +b[0],a[i+1] +b[1], \cdots ,a[i+1] +b[j-1]$ 中的某一个。显然，存在比 $a[i+1] + b[j]$ 还小的方案，肯定不会选到 $a[i+1] + b[j]$，因此增加该限定条件不影响算法正确性。
时间复杂度：
由于我们每次获取并删除一个堆顶，最多往堆中插入两个新的元素，因此每一次堆的大小最多增加 $1$，又因为最多只有 $N$ 次出堆操作且堆初始为空，因此堆的规模最大为 $O(n)$。
因此每次push和pop都是 $O(\log n)$ 的复杂度，而最多做 $O(n)$ 次push和pop，因此 $O(n \log n)$ 就能求得两个序列的前 $n$ 小的和。
而对于 $M>2$ 的情况，可以先求出第一个序列和第二个序列的前 $n$ 小的和，作为一个新序列再去和第三个序列求前 $n$ 小的和，以此类推总的时间复杂度为 $O(mn \log n)$。
AC代码：
手写二叉堆版本（500ms）：
#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> pii;
const int maxm=100+5;
const int maxn=2000+5;
int m,n;
vector<int> a[maxm];
struct Plan{
pii ptr;
bool last; //记录本方案是否是由ptr2++得到的
int sum;
Plan(){}
Plan(int i,int j,pii _ptr,bool _last)
{
ptr=_ptr;
last=_last;
sum=a[i][ptr.first]+a[j][ptr.second];
}
}init;
struct Heap
{
int sz;
Plan heap[3*maxn];
void up(int now)
{
while(now>1)
{
int par=now>>1;
if(heap[now].sum<heap[par].sum) //子节点小于父节点，不满足小顶堆性质
{
swap(heap[par],heap[now]);
now=par;
}
else break;
}
}
void push(const Plan &x) //插入权值为x的节点
{
heap[++sz]=x;
up(sz);
}
inline Plan top(){return heap[1];}
void down(int now)
{
while((now<<1)<=sz)
{
int nxt=now<<1;
if(nxt+1<=sz && heap[nxt+1].sum<heap[nxt].sum) nxt++; //取左右子节点中较小的
if(heap[now].sum>heap[nxt].sum) //子节点小于父节点，不满足小顶堆性质
{
swap(heap[now],heap[nxt]);
now=nxt;
}
else break;
}
}
void pop() //移除堆顶
{
heap[1]=heap[sz--];
down(1);
}
void del(int p) //删除存储在数组下标为p位置的节点
{
heap[p]=heap[sz--];
up(p), down(p);
}
inline void clr(){sz=0;}
}h;
int main()
{
int T;
cin>>T;
while(T--)
{
scanf("%d%d",&m,&n);
for(int i=1;i<=m;i++)
{
a[i].clear();
for(int j=1,x;j<=n;j++)
{
scanf("%d",&x);
a[i].push_back(x);
}
sort(a[i].begin(),a[i].end());
}
int i=1;
for(int j=2;j<=m;j++,i^=1)
{
init=Plan(i,j,make_pair(0,0),0);
h.clr();
h.push(init);
a[i^1].clear();
while(h.sz)
{
Plan now=h.top(); h.pop();
a[i^1].push_back(now.sum);
if(a[i^1].size()>=n) break;
if(!now.last && now.ptr.first<n-1)
h.push(Plan(i,j,make_pair(now.ptr.first+1,now.ptr.second),0));
if(now.ptr.second<n-1)
h.push(Plan(i,j,make_pair(now.ptr.first,now.ptr.second+1),1));
}
}
for(int k=0;k<a[i].size();k++) printf("%d ",a[i][k]);
printf("\n");
}
}
优先队列版本（563ms）：
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> pii;
const int maxm=100+5;
const int maxn=2000+5;
int m,n;
vector<int> a[maxm];
struct Plan{
pii ptr;
bool last; //记录本方案是否是由ptr2++得到的
int sum;
Plan(){}
Plan(int i,int j,pii _ptr,bool _last)
{
ptr=_ptr;
last=_last;
sum=a[i][ptr.first]+a[j][ptr.second];
}
bool operator<(const Plan& oth)const{return sum>oth.sum;}
}init;
priority_queue<Plan> Q;
int main()
{
int T;
cin>>T;
while(T--)
{
scanf("%d%d",&m,&n);
for(int i=1;i<=m;i++)
{
a[i].clear();
for(int j=1,x;j<=n;j++)
{
scanf("%d",&x);
a[i].push_back(x);
}
sort(a[i].begin(),a[i].end());
}
int i=1;
for(int j=2;j<=m;j++,i^=1)
{
init=Plan(i,j,make_pair(0,0),0);
while(!Q.empty()) Q.pop();
Q.push(init);
a[i^1].clear();
while(!Q.empty())
{
Plan now=Q.top(); Q.pop();
a[i^1].push_back(now.sum);
if(a[i^1].size()>=n) break;
if(!now.last && now.ptr.first<n-1)
Q.push(Plan(i,j,make_pair(now.ptr.first+1,now.ptr.second),0));
if(now.ptr.second<n-1)
Q.push(Plan(i,j,make_pair(now.ptr.first,now.ptr.second+1),1));
}
}
for(int k=0;k<a[i].size();k++) printf("%d ",a[i][k]);
printf("\n");
}
}
