HDU 4888 Redraw Beautiful Drawings

http://acm.hdu.edu.cn/showproblem.php?pid=4888

题意:给行数N和列数M，颜色数K，以及每一行的和，每一列的和。问有没有唯一排列方法。

题解：网络流，建模一直是个大问题……根本建不出……看完题解后恍然大悟……

　　　建图：源点到每一行建边，容量为此行之和；每一行和每一列建边，容量为K；每一列和汇点建边，容量为此列之和。

　　　判断是否有解：源点出发的边和到达汇点的  边是否满流。

　　　判断唯一解：残余网络是否有长度大于二的环。（有多条路可选，不影响总流量）（DFS）

         唯一解的结果：G[i][j]的流量。

第一次存边表……当做模板好了……实在是太弱了……

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <numeric>
#include <functional>
#include <set>
#include <fstream>

using namespace std;

const int INF=0xfffffff;
const int maxe=410*410*10;
const int maxn=410+410;

struct edge{
    int to,cap,next;
    edge(int to=0,int cap=0,int next=0):to(to),cap(cap),next(next){}
}G[maxe];
int head[maxn],level[maxn],nedge;
bool used[maxn];
int g[maxn][maxn];
int sumr,sumc;
int N,M,K;
int flag;

void add_edge(int from,int to,int cap)
{
    G[++nedge]=edge(to,cap,head[from]);
    head[from]=nedge;
    G[++nedge]=edge(from,0,head[to]);
    head[to]=nedge;
}

bool bfs(int S,int T)
{
    memset(level,0xff,sizeof(level));
    level[S]=0;
    queue<int>q;
    q.push(S);
    while(!q.empty())
    {
        int v=q.front();q.pop();
        for(int k=head[v];k!=-1;k=G[k].next)
        {
            edge e=G[k];
            if(level[e.to]==-1&&e.cap)
            {
                level[e.to]=level[v]+1;
                q.push(e.to);
            }
        }
    }
    return level[T]!=-1;
}

int dfs(int v,int f,int T)
{
    if(v==T||f==0) return f;
    int flow=0;
    for(int k=head[v];k!=-1;k=G[k].next)
    {
        edge & e=G[k];
        if(level[e.to]==level[v]+1)
        {
            int d;
            if((d=dfs(e.to,min(f,e.cap),T))>0)
            {
                G[k].cap-=d;
                G[k^1].cap+=d;
                flow+=d;
                f-=d;
                if(f==0) return flow;
            }
        }
    }
    level[v]=-1;
    return flow;
}

int max_flow(int s,int t)
{
    int flow=0;
    int f;
    while (bfs(s,t)==1)
    {
        while((f=dfs(s,INF,t))>0)
        {
            flow+=f;
            //printf("%d
",flow);
        }
    }
    return flow;
}

int dfs_loop(int u,int rev)
{
    for(int k=head[u];k!=-1;k=G[k].next)
    {
        if(k==(rev^1)) continue;
        if(G[k].cap)
        {
            if(used[G[k].to]) return 1;
            used[G[k].to]=true;
            if(dfs_loop(G[k].to,k)==1) return 1;
            used[G[k].to]=false;
        }
    }
    return 0;
}

int judge_loop()
{
    for(int i=1;i<=N;i++)
    {
        if(dfs_loop(i,-1))
        {
            return 0;
        }
    }
    return 1;
}

void put()
{
    for(int u=1;u<=N;u++)
    {
        for(int k=head[u];k!=-1;k=G[k].next)
        {
            int v=G[k].to;
            if(v>N&&v<=N+M) g[u][v-N]=K-G[k].cap;
        }
    }
    for(int i=1;i<=N;i++)
    {
        for(int j=1;j<=M;j++)
        {
            if(j>1) printf(" ");
            printf("%d",g[i][j]);
        }
        puts("");
    }
}

void init()
{
    memset(head,0xff,sizeof(head));
    memset(g,0,sizeof(g));
    memset(used,0,sizeof(used));
    nedge=-1;
    sumr=0;
    sumc=0;
    flag=0;
}

int main()
{
   // freopen("/Users/apple/Desktop/暑假/contest 3 B/contest 3 B/in","r",stdin);
    while(scanf("%d%d%d",&N,&M,&K)!=EOF)
    {
        init();
        int s=0;
        int t=N+M+1;
        int cap;
        for(int i=1;i<=N;i++)
        {
            scanf("%d",&cap);
            sumr+=cap;
            add_edge(s, i, cap);//s到行之和 s-（1~N）
            for(int j=1;j<=M;j++)
            {
                add_edge(i,N+j,K);//（1~N）-（N+1~N+M）
            }
        }
        for(int i=1;i<=M;i++)
        {
            scanf("%d",&cap);
            sumc+=cap;
            add_edge(N+i,t,cap);//（N+1~N+M）-t
        }
        int flow1=max_flow(s, t);
        if(sumr!=sumc) puts("Impossible");
        else if(flow1!=sumr) puts("Impossible");
        else if(!judge_loop()) puts("Not Unique");
        else{
            puts("Unique");
            put();
        }
    }
    return 0;
}