HDU3338 Kakuro Extension(最大流)

给出一个大小为n∗m(2≤n,m≤100)n*m(2\leq n,m \leq 100)的数谜，在每个白格子里面填上1~9的数字，使得横向的和等于黑格子右上角的数，竖向的和等于黑格子左下角的数。

我的第一反应，搜索！

但是n,m有100那么大，估计也搜不过。

于是搜了搜题解，才知道网络流可以这样建模：

源点s连向黑格子右上角，容量为黑格子右上角的数，表示需要得到的和；黑格子的右上角分别向它对应的白格子连边，容量为9且流量必须大于等于1，为了方便，我们把容量-1，这样容量变成了8，s连出去的边的容量也要相应的减少对应的白格子数量，输出的时候再加回来，流量的含义为需要填的数；每一列的白格子分别连向它们对应的黑格子左下角，容量均为8，理由同上；最后，每个黑格子左下角再连向汇点，容量为左下角的数减去对应的白格子数，表示需要得到的和。

这样一来，求出的最大流后的残留网络就应该是数谜的一组解，只需要统计连向白格子的边的流量。

很巧妙，对不对！

样例建出来的图大概是这样的，渣渣手绘，请见谅：





其中浅蓝色的点是黑格子右上角，深蓝色的点是黑格子左下角（在图中貌似很模糊- -），红点是白格子。不难发现，每条边的容量都减去了相应的值。

#include<cstdio>
#include<cstring>
#include<vector>
#define MAXN 40010
using namespace std;
inline int Min(int a,int b)
{return a<b?a:b;}
struct E
{
int v,w,op;
E(){}
E(int a,int b,int c)
{v = a; w = b; op = c;}
};
vector<E> g[MAXN];
int d[MAXN],vd[MAXN],n,m,col[110][110],row[110][110],ans[110][110];
int posrow[MAXN],srow[MAXN],cntx,poscol[MAXN],scol[MAXN],cnty,flow;
int s,t;
char str[10];
void init()
{
for(int i = 1; i <= t; i++) g[i].clear();
memset(posrow,0,sizeof posrow);
memset(srow,0,sizeof srow);
memset(poscol,0,sizeof poscol);
memset(scol,0,sizeof scol);
memset(col,0,sizeof col);
memset(row,0,sizeof row);
memset(ans,0,sizeof ans);
cntx = cnty = s = t = 0;
}
void get_num(int i,int j)
{
scanf("%s",str);
if(str[0] == 'X') col[i][j] = -2;
else if(str[0] == '.') col[i][j] = -1;
else col[i][j] = (str[0]-'0')*100+(str[1]-'0')*10+str[2]-'0';

if(str[4] == 'X') row[i][j] = -2;
else if(str[4] == '.') row[i][j] = -1;
else row[i][j] = (str[4]-'0')*100+(str[5]-'0')*10+str[6]-'0';
}
inline int index(int i,int j)//点标号
{
return (i-1)*m+j;
}
inline void back(int dex,int &i,int &j)
{
i = (dex-1)/m+1;
j = dex%m;
if(j == 0) j = m;
}
void build()//输入好恶心- -
{
int tx,p,nS;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
{
if(row[i][j]>=0)
{
tx = index(i,j);
posrow[++cntx] = tx;
srow[cntx] = row[i][j];
}
else if(row[i][j] == -1)
{
srow[cntx]--;//统计对应白格子的数，减去它们
p = index(i,j);
g[tx].push_back(E(p,8,g[p].size()));
g[p].push_back(E(tx,0,g[tx].size()-1));
}
}
s = m*n+1;
nS = s;
for(int i = 1; i <= cntx; i++)//源点s连边
{
g[s].push_back(E(posrow[i],srow[i],g[posrow[i]].size()));
g[posrow[i]].push_back(E(s,0,g[s].size()-1));
}
for(int j = 1; j <= m; j++)
for(int i = 1; i <= n; i++)
{
if(col[i][j] >= 0)
{
poscol[++cnty] = ++nS;
scol[cnty] = col[i][j];
}
else if(col[i][j] == -1)
{
scol[cnty]--;
p = index(i,j);
g[p].push_back(E(poscol[cnty],8,g[poscol[cnty]].size()));
g[poscol[cnty]].push_back(E(p,0,g[p].size()-1));
}
}
t = nS+1;
for(int i = 1; i <= cnty; i++)//向汇点t连边
{
g[poscol[i]].push_back(E(t,scol[i],g[t].size()));
g[t].push_back(E(poscol[i],0,g[poscol[i]].size()-1));
}
}
int aug(int i,int augco)
{
int j,augc = augco,mind = t-1,delta,sz = g[i].size();
if(i == t) return augco;

for(j = 0; j < sz; j++)
{
int v = g[i][j].v;
if(g[i][j].w)
{
if(d[i] == d[v]+1)
{
delta = Min(g[i][j].w,augc);
delta = aug(v,delta);
g[i][j].w -= delta;
g[v][g[i][j].op].w += delta;
augc -= delta;
if(d[s] >= t) return augco - augc;
if(augc == 0) break;
}
if(d[v] < mind) mind = d[v];
}
}
if(augc == augco)
{
vd[d[i]]--;
if(vd[d[i]] == 0) d[s] = t;
d[i] = mind+1;
vd[d[i]]++;
}
return augco - augc;
}
void sap()
{
memset(d,0,sizeof d);
memset(vd,0,sizeof vd);
flow = 0;
vd[0] = t;
while(d[s] < t)
flow += aug(s,0x3f3f3f3f);
}
void solution()
{
int v,ssz = g[s].size(),vsz,to,i,j,x,y;
for(i = 0; i < ssz; i++)
{
v = g[s][i].v;
vsz = g[v].size();
for(j = 0; j < vsz; j++)
{
to = g[v][j].v;
back(to,x,y);//求出该编号对应的点
ans[x][y] = 9-g[v][j].w;
}
}
}
int main()
{
while(scanf("%d%d",&n,&m) != EOF)
{
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
get_num(i,j);

build();//建图

sap();//网络流

solution();

for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
printf("%c%c",ans[i][j]==0?'_':ans[i][j]+'0',j==m?'\n':' ');
printf("\n");
}
init();
}
}