UVa11082 Matrix Decompressing（最小费用最大流）

题目大概有一个n*m的矩阵，已知各行所有数的和的前缀和和各列所有数的和的前缀和，且矩阵各个数都在1到20的范围内，求该矩阵的一个可能的情况。

POJ2396的弱化版本吧。。建图的关键在于：

• 把行、列看成点，各单元看成边

这个建图感觉非常巧。。

各个单元有下界限制。。这个我可不想再写带下界的最大流。。

想了下，发现可以用最小费用最大流求解：通过放大边的费用，使得这条边成为一条必须会被经过的边。

简单来说就是各单元代表的边拆成两条，一条容量1费用-1，另外一条容量19费用0。这样跑MCMF，显然为了让费用最小，所有费用-1的边必然会经过，这样就保证了各个单元的值至少为1。

（其实有个更简单的方法就是所有单元格都同时减去1。。）

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;
#define MAXN 44
#define MAXM 88*88
#define INF (1<<30)

struct Edge{
    int v,cap,cost,next;
}edge[MAXM];
int vs,vt,NV,NE,head[MAXN];
void addEdge(int u,int v,int cap,int cost){
    edge[NE].v=v; edge[NE].cap=cap; edge[NE].cost=cost;
    edge[NE].next=head[u]; head[u]=NE++;
    edge[NE].v=u; edge[NE].cap=0; edge[NE].cost=-cost;
    edge[NE].next=head[v]; head[v]=NE++;
}

int d[MAXN],pre[MAXN];
bool inque[MAXN];
bool SPFA(){
    for(int i=0; i<NV; ++i){
        d[i]=INF; inque[i]=0;
    }
    d[vs]=0; inque[vs]=1;
    queue<int> que;
    que.push(vs);
    while(!que.empty()){
        int u=que.front(); que.pop();
        for(int i=head[u]; i!=-1; i=edge[i].next){
            int v=edge[i].v;
            if(edge[i].cap && d[v]>d[u]+edge[i].cost){
                d[v]=d[u]+edge[i].cost;
                pre[v]=i;
                if(!inque[v]){
                    inque[v]=1;
                    que.push(v);
                }
            }
        }
        inque[u]=0;
    }
    return d[vt]!=INF;
}
int mxflow;
int MCMF(){
    mxflow=0;
    int res=0;
    while(SPFA()){
        int flow=INF,cost=0;
        for(int u=vt; u!=vs; u=edge[pre[u]^1].v){
            flow=min(flow,edge[pre[u]].cap);
        }
        mxflow+=flow;
        for(int u=vt; u!=vs; u=edge[pre[u]^1].v){
            edge[pre[u]].cap-=flow;
            edge[pre[u]^1].cap+=flow;
            cost+=edge[pre[u]].cost;
        }
        res+=cost*flow;
    }
    return res;
}

int row[22],col[22],ans[22][22];
int main(){
    int t,n,m;
    scanf("%d",&t);
    for(int cse=1; cse<=t; ++cse){
        scanf("%d%d",&n,&m);
        vs=0; vt=n+m+1; NV=vt+1; NE=0;
        memset(head,-1,sizeof(head));
        for(int i=1; i<=n; ++i){
            scanf("%d",row+i);
            addEdge(vs,i,row[i]-row[i-1],0);
        }
        for(int i=1; i<=m; ++i){
            scanf("%d",col+i);
            addEdge(i+n,vt,col[i]-col[i-1],0);
        }
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=m; ++j){
                addEdge(i,j+n,1,-1);
                addEdge(i,j+n,19,0);
            }
        }
        MCMF();
        memset(ans,0,sizeof(ans));
        for(int u=1; u<=n; ++u){
            for(int i=head[u]; i!=-1; i=edge[i].next){
                if(i&1) continue;
                int v=edge[i].v-n;
                ans[u][v]+=edge[i^1].cap;
            }
        }
        if(cse!=1) putchar('
');
        printf("Matrix %d
",cse);
        for(int i=1; i<=n; ++i){
            for(int j=1; j<=m; ++j){
                printf("%d ",ans[i][j]);
            }
            putchar('
');
        }
    }
    return 0;
}