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;
}