4 3 1 1111 1111 1111 LLLL LLLL LLLL 3 2 00000 01110 00000 ..... .LLL. ..... 3 1 00000 01110 00000 ..... .LLL. ..... 5 2 00000000 02000000 00321100 02000000 00000000 ........ ........ ..LLLL.. ........ ........
Case #1: 2 lizards were left behind. Case #2: no lizard was left behind. Case #3: 3 lizards were left behind. Case #4: 1 lizard was left behind.
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define captype int
const int MAXN = 1010; //点的总数
const int MAXM = 2000010; //边的总数
const int INF = 1<<30;
struct EDG{
int to,next;
captype cap,flow;
} edg[MAXM];
int eid,head[MAXN];
int gap[MAXN]; //每种距离(或可认为是高度)点的个数
int dis[MAXN]; //每个点到终点eNode 的最短距离
int cur[MAXN]; //cur[u] 表示从u点出发可流经 cur[u] 号边
int pre[MAXN];
void init(){
eid=0;
memset(head,-1,sizeof(head));
}
//有向边 三个参数，无向边4个参数
void addEdg(int u,int v,captype c,captype rc=0){
edg[eid].to=v; edg[eid].next=head[u];
edg[eid].cap=c; edg[eid].flow=0; head[u]=eid++;
edg[eid].to=u; edg[eid].next=head[v];
edg[eid].cap=rc; edg[eid].flow=0; head[v]=eid++;
}
captype maxFlow_sap(int sNode,int eNode, int n){//n是包括源点和汇点的总点个数，这个一定要注意
memset(gap,0,sizeof(gap));
memset(dis,0,sizeof(dis));
memcpy(cur,head,sizeof(head));
pre[sNode] = -1;
gap[0]=n;
captype ans=0; //最大流
int u=sNode;
while(dis[sNode]<n){ //判断从sNode点有没有流向下一个相邻的点
if(u==eNode){ //找到一条可增流的路
captype Min=INF ;
int inser;
for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]) //从这条可增流的路找到最多可增的流量Min
if(Min>edg[i].cap-edg[i].flow){
Min=edg[i].cap-edg[i].flow;
inser=i;
}
for(int i=pre[u]; i!=-1; i=pre[edg[i^1].to]){
edg[i].flow+=Min;
edg[i^1].flow-=Min; //可回流的边的流量
}
ans+=Min;
u=edg[inser^1].to;
continue;
}
bool flag = false; //判断能否从u点出发可往相邻点流
int v;
for(int i=cur[u]; i!=-1; i=edg[i].next){
v=edg[i].to;
if(edg[i].cap-edg[i].flow>0 && dis[u]==dis[v]+1){
flag=true;
cur[u]=pre[v]=i;
break;
}
}
if(flag){
u=v;
continue;
}
//如果上面没有找到一个可流的相邻点，则改变出发点u的距离（也可认为是高度）为相邻可流点的最小距离+1
int Mind= n;
for(int i=head[u]; i!=-1; i=edg[i].next)
if(edg[i].cap-edg[i].flow>0 && Mind>dis[edg[i].to]){
Mind=dis[edg[i].to];
cur[u]=i;
}
gap[dis[u]]--;
if(gap[dis[u]]==0) return ans; //当dis[u]这种距离的点没有了，也就不可能从源点出发找到一条增广流路径
//因为汇点到当前点的距离只有一种，那么从源点到汇点必然经过当前点，然而当前点又没能找到可流向的点，那么必然断流
dis[u]=Mind+1;//如果找到一个可流的相邻点，则距离为相邻点距离+1，如果找不到，则为n+1
gap[dis[u]]++;
if(u!=sNode) u=edg[pre[u]^1].to; //退一条边
}
return ans;
}
int abs(int a){return a>0?a:-a;}
int main(){
int n,d;
char g1[50][50],g2[50][50];
int T,_cas=0;
scanf("%d",&T);
while(T--){
scanf("%d%d",&n,&d);
for(int i=0; i<n; i++)
scanf("%s",g1[i]);
for(int i=0; i<n; i++)
scanf("%s",g2[i]);
init();
int m=strlen(g1[0]);
//点本身作为一个边,点i*m+j+1入渡只来自外界，出度只有一个，也就是自身的另一个点 i*m+j+1+n*m, 点i*m+j+1+n*m 只有出度
for(int i=0; i<n; i++)
for(int j=0; j<m; j++)
if(g1[i][j]!='0')
addEdg(i*m+j+1 , i*m+j+1+n*m , g1[i][j]-'0');
int s=0 , t=2*n*m+1; //源点，汇点
for(int i=0; i<n; i++)//起始位置(i,j),可到达的位置(ti,tj)
for(int j=0; j<m; j++)
if(g1[i][j]!='0'){
if(i+d>=n || i-d<0 || j+d>=m || j-d<0){ //可以出界，也就是到达汇点
addEdg(i*m+j+1+n*m , t , g1[i][j]-'0'); continue;
}
for(int ti=i-d; ti<=i+d; ti++)
if(ti>=0&&ti<n)
for(int tj=j-d; tj<=j+d; tj++)
if(tj>=0&&tj<m && (ti!=i || tj!=j)){
if(abs(ti-i)+abs(tj-j)>d||g1[ti][tj]=='0')
continue;
addEdg(i*m+j+1+n*m , ti*m+tj+1 , g1[i][j]-'0');//边的容量只要是>=g1[i][j]-'0'都可以
}
}
int ans=0;
for(int i=0; i<n; i++)
for(int j=0; j<m; j++)
if(g2[i][j]=='L'){
addEdg(s , i*m+j+1, 1) , ans++;
}
ans -= maxFlow_sap(s , t , t+1);
if(ans>1)
printf("Case #%d: %d lizards were left behind.\n",++_cas , ans );
else if(ans==1)
printf("Case #%d: %d lizard was left behind.\n",++_cas , ans );
else
printf("Case #%d: no lizard was left behind.\n",++_cas );
}
}
HDU2732Leapin' Lizards（最大流SAP，建图---折点法）
原文地址：http://blog.csdn.net/u010372095/article/details/46472957
