POJ 2442 Sequence

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

思路：每次找出前两个序列的前n大，然后将这前n大当成新的序列与第三行处理，以此类推。取出堆顶元素的下标为(i, j)时，将(i, j + 1)与(i + 1, j)加入决策集。复杂度nmlogn.

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int T, m, n, a[105][2015], b[2015], c[2015], rec[2015];
struct gg {
    int i, j, k;
    gg () {}
    gg (int i, int j, int k) : i(i), j(j), k(k) {}
    bool operator > (const gg &g) const {
        if (a[i][j] + b[k] == a[g.i][g.j] + b[g.k]) {
            return j + k > g.j + g.k;
        }
        return a[i][j] + b[k] > a[g.i][g.j] + b[g.k];
    }
};
priority_queue<gg, vector<gg>, greater<gg> > que;
int main() {
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &m, &n);
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                scanf("%d", &a[i][j]);
            }
            sort(a[i] + 1, a[i] + n + 1);
        }
        for (int i = 1; i <= n; ++i) {
            b[i] = a[1][i];
        }
        for (int i = 2; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                rec[j] = 0;
            }
            while (que.size()) que.pop();
            que.push(gg(i, 1, 1));
            int index = 0;
            while (que.size() && index < n) {
                gg g = que.top(); que.pop();
                int jj = g.j, kk = g.k;
                if (kk <= rec[jj]) continue;
                else rec[jj] = kk;
                if (jj < n) {
                    que.push(gg(i, jj + 1, kk));
                }
                if (kk < n) {
                    que.push(gg(i, jj, kk + 1));
                }
                c[++index] = a[i][jj] + b[kk];
            }
            for (int j = 1; j <= n; ++j) {
                b[j] = c[j];
            }
        }
        for (int i = 1; i < n; ++i) {
            printf("%d ", b[i]);
        }
        printf("%d 
", b[n]);
    }
    return 0;
}