HDOJ 3046 - Pleasant sheep and big big wolf 构图最小割

本文介绍了一种通过构建特殊图并使用最大流算法来解决矩阵中狼无法到达羊的问题的方法。具体步骤包括构建超级源点、目标点和中间点之间的边,并设置相应的容量值,最终通过运行最大流算法得到答案。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

                   题意:

                             在一个R*C的矩阵中..0代表是空地..1代表是羊..2代表是狼..可以封锁一些边..封锁了一条边后..无论是羊还是狼都无法穿过...现在问封锁最少的边让所有的狼都无法到羊....

                   题解:

                             超级汇点向所有的狼做边..容量为无穷大...所有的点向四周做边.容量为1...所有的羊向超级汇点做边..容量为1...跑最大流(=最小割)..即为答案.


Program:

#include<iostream>    
#include<algorithm>    
#include<stdio.h>    
#include<string.h>  
#include<time.h> 
#include<map> 
#include<math.h>    
#include<queue>    
#define MAXN 100005 
#define MAXM 2000005   
#define oo 1000000007    
#define ll long long    
using namespace std;   
struct Dinic          
{          
       struct node        
       {         
             int c,u,v,next;        
       }edge[MAXM];        
       int ne,head[MAXN];        
       int cur[MAXN], ps[MAXN], dep[MAXN];        
       void initial()        
       {        
             ne=2;        
             memset(head,0,sizeof(head));         
       }        
       void addedge(int u, int v,int c)        
       {         
             edge[ne].u=u,edge[ne].v=v,edge[ne].c=c,edge[ne].next=head[u];        
             head[u]=ne++;        
             edge[ne].u=v,edge[ne].v=u,edge[ne].c=0,edge[ne].next=head[v];        
             head[v]=ne++;        
       }        
       int MaxFlow(int s,int t)        
       {                             
             int tr, res = 0;        
             int i,j,k,f,r,top;        
             while(1)        
             {        
                    memset(dep, -1, sizeof(dep));        
                    for(f=dep[ps[0]=s]=0,r=1;f!= r;)        
                       for(i=ps[f++],j=head[i];j;j=edge[j].next)        
                         if(edge[j].c&&dep[k=edge[j].v]==-1)        
                         {        
                               dep[k]=dep[i]+1;        
                               ps[r++]=k;        
                               if(k == t){  f=r; break;  }        
                         }        
                    if(dep[t]==-1) break;        
                    memcpy(cur,head,sizeof(cur));        
                    i=s,top=0;        
                    while(1)        
                    {        
                         if(i==t)        
                         {        
                               for(tr=oo,k=0;k<top;k++)        
                                  if(edge[ps[k]].c<tr)        
                                     tr=edge[ps[f=k]].c;        
                               for(k=0;k<top;k++)        
                               {        
                                     edge[ps[k]].c-=tr;        
                                     edge[ps[k]^1].c+=tr;        
                               }        
                               i=edge[ps[top=f]].u;        
                               res+= tr;        
                         }        
                         for(j=cur[i];cur[i];j=cur[i]=edge[cur[i]].next)         
                             if(edge[j].c && dep[i]+1==dep[edge[j].v]) break;         
                         if(cur[i])  ps[top++]=cur[i],i=edge[cur[i]].v;         
                         else        
                         {        
                                 if(!top) break;        
                                 dep[i]=-1;        
                                 i=edge[ps[--top]].u;        
                         }        
                   }        
             }        
             return res;        
      }        
}T;    
int main()   
{            
      int R,C,cases=0,i,j,p,x,s,e;
      while (~scanf("%d%d",&R,&C))
      {
              s=R*C+5,e=s+1,T.initial();
              for (i=0;i<R;i++)
                 for (j=0;j<C;j++)
                 {
                       scanf("%d",&x),p=i*C+j;
                       if (x==2) T.addedge(s,p,oo);
                       if (x==1) T.addedge(p,e,oo);
                       if (i) T.addedge(p,p-C,1);
                       if (j) T.addedge(p,p-1,1);
                       if (i!=R-1) T.addedge(p,p+C,1);
                       if (j!=C-1) T.addedge(p,p+1,1);
                 }
              printf("Case %d:\n%d\n",++cases,T.MaxFlow(s,e));              
      }
      return 0;  
}  


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值