HDU-3338 Kakuro Extension

像是一个数独问题，在n*m的矩阵里，有黑格子和白格子

如果黑格子右边为白格子，则会有一个数字sumr，代表右边连续白格子中的数的和

如果黑格子下边为白格子，则会有一个数字sumd，代表下边连续白格子中的数的和

给出黑格子和sumr,sumd，白格子，要求在白格子中添数，满足上边的要求

首先要发现一个规律，所有竖着的数字sumd的和等于所有横着的数字sumr的和

而一个白格子始终会对应着两个数字，一个sumr，一个sumd，两个数字都包含他

那么可以把问题抽象为最大流的问题

从sumd流向sumr，通过这些白格子作为边

那么建立源点连向sumd，边权为sumd，sumr连向汇点，边权为sumr

白格子连接它左边第一个sumr和上边第一个sumd，容量为8

（我这么设置，应对数字要求1~9，相当于每个白格子中的数字-1，sumr和sumd都减去对应的值）

然后跑一边ISAP，统计这些边的流量，填入白格子

前面的建图，和后面的提取流量，都要下一番功夫

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
const int maxn=100+10;
const int N=6000+10;
const int M=3e4+10;
const int INF=0x7f7f7f7f;
struct Edge
{
	int to,nxt,cap,flow;
	int x,y;
	int f;
}edge[M];
int tot,first[N];
void addedge(int u,int v,int w,int rw=0,int x=-1,int y=-1,int f=0)
{
	edge[tot].x=x;edge[tot].y=y;edge[tot].f=f;
	edge[tot].to=v;edge[tot].cap=w;edge[tot].flow=0;
	edge[tot].nxt=first[u];first[u]=tot++;
	edge[tot].x=x;edge[tot].y=y;edge[tot].f=0;
	edge[tot].to=u;edge[tot].cap=rw;edge[tot].flow=0;
	edge[tot].nxt=first[v];first[v]=tot++;
}
void init()
{
	tot=0;
	memset(first,-1,sizeof(first));
}

int gap[N],dep[N],cur[N];
int Q[N],S[N];
void bfs(int s)
{
	memset(dep,-1,sizeof(dep));
	memset(gap,0,sizeof(gap));
	int q0=0,q1=0;
	Q[q1++]=s;
	dep[s]=0;
	gap[0]=1;
	while(q0<q1)
	{
		int u=Q[q0++];
		for(int i=first[u];i!=-1;i=edge[i].nxt)
		{
			int v=edge[i].to;
			if(dep[v]!=-1) continue;
			dep[v]=dep[u]+1;
			gap[dep[v]]++;
			Q[q1++]=v;
		}
	}
}
int sap(int s,int t,int n)
{
	int ans=0;
	bfs(t);
	memcpy(cur,first,sizeof(first));
	int top=0;
	int u=s;
	while(dep[s]<n)
	{
		if(u==t)
		{
			int Min=INF;
			int inser;
			for(int i=0;i<top;i++)
				if(Min>edge[S[i]].cap-edge[S[i]].flow)
				{
					Min=edge[S[i]].cap-edge[S[i]].flow;
					inser=i;
				}
			for(int i=0;i<top;i++)
			{
				edge[S[i]].flow+=Min;
				edge[S[i]^1].flow-=Min;
			}
			ans+=Min;
			top=inser;
			u=edge[S[top]^1].to;
		}
		bool flag=false;
		int v;
		for(int i=cur[u];i!=-1;i=edge[i].nxt)
		{
			v=edge[i].to;
			if(edge[i].cap-edge[i].flow&&dep[v]+1==dep[u])
			{
				flag=true;
				cur[u]=S[top++]=i;
				break;
			}
		}
		if(flag)
		{
			u=v;
			continue;
		}
		gap[dep[u]]--;
		if(!gap[dep[u]]) return ans;
		int Min=n;
		for(int i=first[u];i!=-1;i=edge[i].nxt)
			if(edge[i].cap-edge[i].flow&&Min>dep[edge[i].to])
			{
				Min=dep[edge[i].to];
				cur[u]=i;
			}
		dep[u]=Min+1;
		gap[dep[u]]++;
		if(u!=s) u=edge[S[--top]^1].to;
	}
	return ans;
}
int up[maxn][maxn],down[maxn][maxn],lef[maxn][maxn],rig[maxn][maxn];
int idr[maxn][maxn],idd[maxn][maxn];
string s;
char ans[maxn][maxn];
int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		init();
		memset(up,-1,sizeof(up));
		memset(down,-1,sizeof(down));
		memset(lef,-1,sizeof(lef));
		memset(rig,-1,sizeof(rig));
		int cnt=1;
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
			{
				cin>>s;
				if(s[3]=='\\')
				{
					int t;
					if(s[0]!='X')
					{
						t=(s[0]-'0')*100+(s[1]-'0')*10+s[2]-'0';
						idd[i][j]=cnt++;
						down[i][j]=t;
					}
					if(s[4]!='X')
					{
						t=(s[4]-'0')*100+(s[5]-'0')*10+s[6]-'0';
						idr[i][j]=cnt++;
						rig[i][j]=t;
					}
				}
				else if(s[3]=='.')
				{
					for(int k=i;k>=0;k--)
						if(down[k][j]!=-1)
						{
							up[i][j]=idd[k][j];
							down[k][j]--;
							break;
						}
					for(int k=j;k>=0;k--)
						if(rig[i][k]!=-1)
						{
							lef[i][j]=idr[i][k];
							rig[i][k]--;
							break;
						}
				}
			}
		int s=0,t=cnt;
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
			{
				if(down[i][j]!=-1)
					addedge(s,idd[i][j],down[i][j]);
				if(rig[i][j]!=-1)
					addedge(idr[i][j],t,rig[i][j]);
				if(lef[i][j]!=-1)
					addedge(up[i][j],lef[i][j],8,0,i,j,1);
			}
		sap(s,t,t+1);
		memset(ans,'_',sizeof(ans));
		for(int i=0;i<tot;i++)
			if(edge[i].f&&edge[i].x!=-1)
			{
				ans[edge[i].x][edge[i].y]='0'+edge[i].flow+1;
			}
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m-1;j++)
				printf("%c ",ans[i][j]);
			printf("%c\n",ans[i][m-1]);
		}
	}
	return 0;
}