hdu2732 最大流+拆点

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2732

题目给定一个场景，有n*m个方格，每个方格代表一个柱子，一个柱子可以承受不同次数的跳跃，开始时图中给定一些地方有蜥蜴，并且给定蜥蜴最多跳跃的步长，只要跳到方格之外就能安全，而且每只蜥蜴不能在同一个地方重合，每次蜥蜴跳离一个地方这个地方的柱子就的承受次数就会减一，问最终会有多少只蜥蜴不能跳出迷宫。

这个问题可以这样思考，每次蜥蜴跳出一个位置之后这个位置的“资源”就会减少1，而这个减少之后的“资源”不可以再利用，而且涉及到点之间的转移，这在图论中和最大流很相似，所以我们想到可不可以将点转化成状态，地图中的每一个位置（i,j）（0<=i,j<n）可以通过i*m+j+1转化成[1,n*m]闭区间之内的位置，所以我们可以把这个设为他的id，可以将点位置拆开成两个，一个是id，表示没有转移时的状态，另一个点是id+n*m,表示这个点拆开之后的另一个状态。设置一个超级源和一个超级汇。

转换策略如下：

①、如果一个点位置（i,j）值num大于0，那么可以连边（id,id+n*m,num），表示最多有num次“流”在这个位置转换，num个用完也就代表不能发生转换，也就是这个位置不能站蜥蜴了。

②、如果一个位置通过跳跃d可以到达外围就设置边（id,T,inf）,就是把这个位置和超级汇连接起来，并且不限制从这里通过的蜥蜴的数量。

③、如果一个位置有蜥蜴，我们可以把这个位置和超级源连接在一起，也就是（S,id,1）1表示在这个位置有一只蜥蜴出发。就相当于把蜥蜴放在一个源点，蜥蜴数量便是源点流量。

④、两个位置之间的距离（横纵坐标绝对值之差）如果小于d那就可以转换，注意连的边是（id+n*m,id2,1），因为在他跳出当前位置时必须当前位置的承受容量减一，所以必须重跳完之后的状态转移。

基本思想就是拆点。需要慎重思考转移的方式。

 #include<bits/stdc++.h>
 using namespace std;
 typedef unsigned int ui;
 typedef long long ll;
 typedef unsigned long long ull;
 #define pf printf
 #define mem(a,b) memset(a,b,sizeof(a))
 #define prime1 1e9+7
 #define prime2 1e9+9
 #define pi 3.14159265
 #define lson l,mid,rt<<1
 #define rson mid+1,r,rt<<1|1
 #define scand(x) scanf("%llf",&x)
 #define f(i,a,b) for(int i=a;i<=b;i++)
 #define scan(a) scanf("%d",&a)
 #define mp(a,b) make_pair((a),(b))
 #define P pair<int,int>
 #define dbg(args) cout<<#args<<":"<<args<<endl;
 #define inf 0x7ffffff
 inline int read(){
     int ans=,w=;
     char ch=getchar();
     while(!isdigit(ch)){if(ch=='-')w=-;ch=getchar();}
     while(isdigit(ch))ans=(ans<<)+(ans<<)+ch-'',ch=getchar();
     return ans*w;
 }
 const int maxn=;
 const int maxm=;
 struct flow{
     int s,t;
     int head[maxn],nxt[maxm],d[maxn],cur[maxn];//cur当前弧优化
     bool vis[maxn];
     struct node{
         int u,v,w;
     }p[maxm];
     int e;
     void init()
     {
         e=;
         mem(head,-);
         mem(nxt,-);
     }
     void addedge(int u,int v,int w)//顺带添加反向边
     {
         p[e].u=u;
         p[e].v=v;
         p[e].w=w;
         nxt[e]=head[u];
         head[u]=e++;
         p[e].u=v;
         p[e].v=u;
         p[e].w=;
         nxt[e]=head[v];
         head[v]=e++;
     }
     bool bfs(int src,int sink)//确定bfs序
     {
         mem(vis,);
         mem(d,);
         d[src]=;
         vis[src]=;
         queue<int> q;
         q.push(src);
         while(!q.empty())
         {
             int cur=q.front();
             q.pop();
             for(int i=head[cur];~i;i=nxt[i])
             {
                 int v=p[i].v;
                 if(!vis[v]&&p[i].w)//确定这个点没有被标号，并且不是反向边
                 {
                     vis[v]=;
                     d[v]=d[cur]+;
                     q.push(v);
                 }
             }
         }
         if(d[sink])return true;
         return false;
     }
     int dfs(int s,int flow)
     {
         if(s==t)return flow;
         int used=;
         for(int& i=cur[s];~i;i=nxt[i])
         {
             int v=p[i].v,w=p[i].w;
             if(d[v]==d[s]+&&w>)//根据Dinic算法的思想，只能走正向的、bfs序大一的边
             {
                 int tmp=dfs(v,min(flow-used,w));
                 if(tmp>)
                 {
                     p[i].w-=tmp;//更新正向边的流量以及反向边的流量，
                     p[i^].w+=tmp;//正向边是偶数，它对应的反向边就是正向边+1
                     used+=tmp;//从一个点出发最多的流量是flow，用掉的流量需要更新
                     if(used==flow)break;
                  }
             }
         }
         if(!used)d[s]=;//从该点出发的流不能被使用，所以这个点在这次搜索中被丢弃
         return used;
     }
     int dinic()
     {
         int ans=;
         while(bfs(s,t))
         {
             memcpy(cur,head,sizeof(head));
             ans+=dfs(s,inf);
         }
         return ans;
     }
 }a;
 int d;
 int t;
 char s[];
 int main()
 {
     //freopen("input.txt","r",stdin);
     //freopen("output.txt","w",stdout);
     std::ios::sync_with_stdio(false);
     t=read();
     int n,m;
     int kase=;
     while(t--)
     {
         a.init();
         int cnt=;
         n=read(),d=read();
         f(i,,n-)
         {
             scanf(" %s",s);
             if(i==)
             {
                 m=strlen(s);
 //                a.n=2*n*m+2;//最大流中点的数量设置
                 a.s=;
                 a.t=*n*m+;//设置超级源与超级汇
             }
             f(j,,m-)
             {
                 int num=s[j]-'';
                 if(num>)//将大于零的格子拆开成两个格子，并连线，
                 {
                     int id=i*m+j+;
                     a.addedge(id,id+n*m,num);
                     if(i-d<||i+d>=n||j-d<||j+d>=m)
                     {
                         a.addedge(id+n*m,a.t,inf);//可以到达安全地点，且流的大小不限制
                     }
                     else
                     {
                         f(k,,n-)//由于图的大小不大，所以可以枚举每一个位置检查是否可行
                             f(l,,m-)
                             {
                                 int id2=k*m+l+;
                                 if(id==id2)continue;
                                 if(abs(i-k)+abs(j-l)<=d)
                                     a.addedge(id+n*m,id2,inf);//从id位置能够跳到id2位置，但是记住一定是在id位置少1之后的结点上
                             }
                      }
                 }
             }
         }
             f(i,,n-)
             {
                 scanf(" %s",s);
                 f(j,,m-)
                 {
                     if(s[j]=='L')//记录蜥蜴的数量并与超级源连线，
                     {
                         cnt++;
                         int id=i*m+j+;
                         a.addedge(a.s,id,);
                     }
                 }
             }
             int ans=cnt-a.dinic();
             if(ans==)pf("Case #%d: no lizard was left behind.\n",++kase);
             else if(ans==)pf("Case #%d: 1 lizard was left behind.\n",++kase);
             else pf("Case #%d: %d lizards were left behind.\n",++kase,ans);        

     }
 }