Codeforces 274D Lovely Matrix（拓扑排序+建图）

D. Lovely Matrix
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
Lenny had an n × m matrix of positive integers. He loved the matrix so much, because each row of the matrix was sorted in non-decreasing order. For the same reason he calls such matrices of integers lovely.

One day when Lenny was at school his little brother was playing with Lenny’s matrix in his room. He erased some of the entries of the matrix and changed the order of some of its columns. When Lenny got back home he was very upset. Now Lenny wants to recover his matrix.

Help him to find an order for the columns of the matrix so that it’s possible to fill in the erased entries of the matrix to achieve a lovely matrix again. Note, that you can fill the erased entries of the matrix with any integers.

Input
The first line of the input contains two positive integers n and m (1 ≤ n·m ≤ 105). Each of the next n lines contains m space-separated integers representing the matrix. An integer -1 shows an erased entry of the matrix. All other integers (each of them is between 0 and 109 inclusive) represent filled entries.

Output
If there exists no possible reordering of the columns print -1. Otherwise the output should contain m integers p1, p2, …, pm showing the sought permutation of columns. So, the first column of the lovely matrix will be p1-th column of the initial matrix, the second column of the lovely matrix will be p2-th column of the initial matrix and so on.

Examples
input
3 3
1 -1 -1
1 2 1
2 -1 1
output
3 1 2
input
2 3
1 2 2
2 5 4
output
1 3 2
input
2 3
1 2 3
3 2 1
output
-1

题目大意

　　有一个$N \cdot M$的矩阵$(1\leqslant N \cdot M \leqslant 10^5)$。$-1$表示可以换成任意一个数，让你交换一些列，使得每一行都非严格递增。

解题思路

　　由于要求非严格递增，所以我们可以忽略$-1$，把每一列看作一个点，那么对于每一行的权值，让小的指向大的，我们就得到了一些列约束关系，最后对这张图拓扑排序就可以得到最后列的顺序，如果排序失败则无解。
　　不过这样对于行都需要建立$O(M^2)$的边，显然会TLE。考虑网络流中常用建图方式。对于每一行，对每一组相同权值的点建立一个入点一个出点，建立入点到每个这个权值的列的边和每个这个权值的列到出点的边。然后对于每一行的大小约束关系我们只需要连接最接近的权值的入点出点即可。总边数$O(M)$。

AC代码

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <cstdlib>
#include <string>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define LL long long
#define fi first
#define se second
#define mem(a,b) memset((a),(b),sizeof(a))
#define sqr(x) ((x)*(x))

const int MAXN=100000+3;
const int MAXV=MAXN*3;

int N, M, cnt;
vector<int> maze[MAXN];//val, id
vector<int> G[MAXV], ans;
int in[MAXV];//每个点的入度
queue<int> que;
map<pair<int, int>, int> to_id;

int main()
{
    scanf("%d%d", &N, &M);
    cnt=M;
    for(int i=0;i<N;++i)
    {
        for(int j=0;j<M;++j)
        {
            int tmp;
            scanf("%d", &tmp);
            if(tmp==-1)
                continue;
            //对于每一行的相同值建立一个入点一个出点
            if(to_id.find(make_pair(i, tmp))==to_id.end())
            {
                maze[i].push_back(tmp);
                to_id[make_pair(i, tmp)]=cnt;
                cnt+=2;
            }
            int id=to_id[make_pair(i, tmp)];
            G[id].push_back(j);
            ++in[j];
            G[j].push_back(id+1);
            ++in[id+1];
        }
    }
    for(int i=0;i<N;++i)
        sort(maze[i].begin(), maze[i].end());
    for(int i=0;i<N;++i)
        for(int j=1;j<maze[i].size();++j)//只连接权值最接近且不相同的点
        {
            int u=to_id[make_pair(i, maze[i][j-1])], v=to_id[make_pair(i, maze[i][j])];
            G[u+1].push_back(v);
            ++in[v];
        }
    //拓扑排序
    for(int i=0;i<cnt;++i)
        if(!in[i])
            que.push(i);
    while(!que.empty())
    {
        int u=que.front(); que.pop();
        if(u<M)
            ans.push_back(u);
        for(int i=0;i<G[u].size();++i)
        {
            int v=G[u][i];
            --in[v];
            if(!in[v])
                que.push(v);
        }
    }
    if(ans.size()!=M)
    {
        puts("-1");
        return 0;
    }
    for(int i=0;i<M;++i)
        printf("%d%c", ans[i]+1, i==M-1?'\n':' ');

    return 0;
}