HDU 4888 Redraw Beautiful Drawings 网络流（矩阵模型）

题意：给你n*m的矩阵，告诉你每行，每列的和，问你每个小格子的数，如果答案唯一输出之，不唯一，不输出，没有答案输出不可能。

想法：

<1>用到了矩阵模型：模拟超级原点和汇点，source和sink

1.source到每一行，连一条容量为该行和的边

2.每一列到sink，连一条容量为该列和的边

3.每一行和每一列，连一条容量为每个小格子可以填的数的最大值k

这就是矩阵模型的建边，其中3.建边不易理解，其实每一行到每一列建边，不就表示这一行的流量可以到达第1，2，3……n列吗！！！那么在知道行和列的情况下，我们就已经知道了，这个小格子里面应该填写的数字。

<2>如何找到，每个小格子内的填写数字

那么我们知道，数字的填写就在Edge(行，列)这条边上，所以应该在残留网络里面去寻找。对于Edge(行，列)这条边来说还有一个反向边，那么他们分别表示什么意思呢？学过网络流的都知道，正向边的容量为还有多少容量可以供流量使用，反向边的容量是已经用了多少流量，那么这里类似，正向边表明这个格子的数字还可以增加多少，反向边表明这个格子已经添入了多大的数字。

<3>如何判断答案是否唯一，正解：解唯一的充分必要条件是完成最大流后的残余网络没有长度大于2的环。

如果在行，列的点里面如果存在环，并且每一个变得flow>0,表明这些都可以分配，那么对于一个环来说，一个边权值变化k，下一个边权值逆变化k……因为是环他们的总权是不变的。具体证明不会！！！

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#define inf 0x7fffffff 
using namespace std;
const int nodes=810;
const int edges=400000;
int n,m,k,sum1,sum2,flag;
int s,t,x[400+5],y[400+5],map[405][405];
struct node 
{
    int u,v,next;
    int flow;
}e[edges];
int head[nodes],cur[nodes],cnt;
int vis[nodes];
class Dinic
{
    public:
        int spath()
        {
            queue<int>q;
            while(!q.empty()) q.pop();
            memset(dis,-1,sizeof(dis));
            dis[s]=0;
            q.push(s);
            while(!q.empty())
            {
                int u=q.front();
                q.pop();
                for(int i=head[u];i+1;i=e[i].next)
                {
                    int v=e[i].v;
                    if(dis[v]==-1&&e[i].flow>0)
                    {
                        dis[v]=dis[u]+1;
                        q.push(v);
                    }
                }
            }
            return dis[t]!=-1;
        }
        int Min(int a,int b)
        {
            if(a<b) return a;
            return b;
        }
        int dfs(int u,int flow)
        {
            int cost=0;
            if(u==t) return flow;
            for(int &i=cur[u];i+1;i=e[i].next)
            {
                int v=e[i].v;
                if(dis[v]==dis[u]+1&&e[i].flow>0)
                {
                    int min=dfs(v,Min(e[i].flow,flow-cost));
                    if(min>0)
                    {
                        e[i].flow-=min;
                        e[i^1].flow+=min;
                        cost+=min;
                        if(cost==flow) break;
                    }
                    else dis[v]=-1;
                }
            }
            return cost;
        }
        int result()
        {
            int res=0;
            while(spath())
            {
            	for(int i=s;i<=t;i++) cur[i]=head[i];
                res+=dfs(s,inf);
            }
            return res;
        }
    private:
        int dis[nodes];
}dinic;
void Init()
{
    s=0;t=n+m+1;sum1=sum2=0;
    memset(head,-1,sizeof(head));
    cnt=0;
} 
void add(int a,int b,int c)
{
    e[cnt].v=b;
    e[cnt].flow=c;
    e[cnt].next=head[a];
    head[a]=cnt++;
    
    e[cnt].v=a;
    e[cnt].flow=0;
    e[cnt].next=head[b];
    head[b]=cnt++;
}
void build_map()
{
    for(int i=1;i<=n;i++) add(s,i,x[i]);
    for(int i=1;i<=m;i++) add(n+i,t,y[i]);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        add(i,n+j,k);
    }
}
bool judge(int u,int fa)
{
    if(flag) return true;
    for(int i=head[u];i+1;i=e[i].next)
    {
        int v=e[i].v;
        if(v!=fa&&v!=s&&v!=t&&e[i].flow>0)
        {
            if(!vis[v])
            {
                vis[v]=1;
                if(judge(v,u)) return true;
                vis[v]=0;
            }
            else 
            {
                flag=1;
                return true;
            }
            if(flag) return true;
        }
    }
    return false;
}
void treatment()
{
    int maxflow=dinic.result();
    if(sum1!=sum2||(sum1==sum2&&sum1!=maxflow))
    {
        printf("Impossible\n");
        return;
    }
    memset(vis,0,sizeof(vis));
    flag=0;
    for(int i=1;i<=n;i++)
    {
        vis[i]=1;
        if(judge(i,-1)) break;
        vis[i]=0;
    }
    if(flag) 
    {
        printf("Not Unique\n");
        return;
    }
    printf("Unique\n");
    for(int i=1;i<=n;i++)
    {
        int num=1;
        for(int j=head[i];j+1;j=e[j].next)
        {
            int v=e[j].v;
            if(v==i||v==s||v==t) continue;
            map[i][num++]=e[j^1].flow;
        }
    }
    for(int i=1;i<=n;i++)
    {
        int mark=0;
        for(int j=m;j>=1;j--)
        {
            if(mark) printf(" ");
            else mark=1;
            printf("%d",map[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        Init();
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&x[i]);
            sum1+=x[i]; 
        }
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&y[i]);
            sum2+=y[i];
        }
        build_map();
        treatment();
    } 
    return 0;
}