HDU 3987 && DINIC

很容易发现是网络流的题目，但最少边怎么求呢？初时想不到，但画图后忽然发现可以这样：

求一次网络流最小割后，把满流的边置1，不满流的置INF。再求一次最大流即可。

为什么呢？

是否会存在一些边当前不满流，但有可能是最少边数最少割的边呢？否。因为按照DINIC的求法，每次都是增广容量最少的路，若当前不满流，则必定不是最小割的边，所以只需在满流的边，即可组成最小割的边寻找最少边就可以了。

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 using namespace std;

 const int INF=0x3f3f3f3f;
 const int MAXN=;
 const int MAXM=;

 struct Node{
     int from,to,next;
     int cap;
 }edge[MAXM];
 int tol;

 int dep[MAXN];
 int head[MAXN];

 int n,m;
 void init(){
     tol=;
     memset(head,-,sizeof(head));
 }
 void addedge(int u,int v,int w){
     edge[tol].from=u;
     edge[tol].to=v; edge[tol].cap=w;  edge[tol].next=head[u];
     head[u]=tol++;
     edge[tol].from=v;
     edge[tol].to=u;
     edge[tol].cap=;
     edge[tol].next=head[v];
     head[v]=tol++;
 }

 int BFS(int start,int end){
     int que[MAXN];
     int front,rear; front=rear=;
     memset(dep,-,sizeof(dep));
     que[rear++]=start;
     dep[start]=;
     while(front!=rear)    {
         int u=que[front++];
         if(front==MAXN)front=;
         for(int i= head[u];i!=-; i=edge[i].next){
             int v=edge[i].to;
             if(edge[i].cap>&& dep[v]==-){
                 dep[v]=dep[u]+;
                 que[rear++]=v;
                 if(rear>=MAXN) rear=;
                 if(v==end)return ;
             }
         }
     }
     return ;
 }
 int dinic(int start,int end){
     int res=;
     int top;
     int stack[MAXN];
     int cur[MAXN];
     while(BFS(start,end)){
         memcpy(cur,head, sizeof(head));
         int u=start;
         top=;
         while(){
             if(u==end){
                 int min=INF;
                 int loc;
                for(int i=;i<top;i++)
                   if(min>edge [stack[i]].cap) {
                       min=edge [stack[i]].cap;
                       loc=i;
                   }
                 for(int i=;i<top;i++){
                     edge[stack[i]].cap-=min;
                     edge[stack[i]^].cap+=min;
                 }
                 res+=min;
                 top=loc;
                 u=edge[stack[top]].from;
             }
             for(int i=cur[u]; i!=-; cur[u]=i=edge[i].next)
               if(edge[i].cap!= && dep[u]+==dep[edge[i].to])
                  break;
             if(cur[u] !=-){
                 stack [top++]= cur[u];
                 u=edge[cur[u]].to;
             }
             else{
                 if(top==) break;
                 dep[u]=-;
                 u= edge[stack [--top] ].from;
             }
         }
     }
     return res;
 }

 int main(){
     int T,cas=;
     int u,v,w,d;
     scanf("%d",&T);
     while(T--){
         init();
         cas++;
         scanf("%d%d",&n,&m);
         for(int i=;i<m;i++){
             scanf("%d%d%d%d",&u,&v,&w,&d);
             if(d){
                 addedge(v,u,w);
             }
             addedge(u,v,w);
         }
         dinic(,n-);
         for(int i=;i<tol;i+=){
             if(edge[i].cap==){
                 edge[i].cap=; edge[i^].cap=;
             }
             else {
                 edge[i].cap=INF;
                 edge[i^].cap=;
             }
         }
         int ans=dinic(,n-);
         printf("Case %d: ",cas);
         printf("%d\n",ans);
     }
     return ;
 }

DINIC的模板

 const int INF=0x3f3f3f3f;
 const int MAXN=;
 const int MAXM=;

 struct Node{
     int from,to,next;
     int cap;
 }edge[MAXM];
 int tol;

 int dep[MAXN];
 int head[MAXN];

 int n,m;
 void init(){
     tol=;
     memset(head,-,sizeof(head));
 }
 void addedge(int u,int v,int w){
     edge[tol].from=u;
     edge[tol].to=v; edge[tol].cap=w;  edge[tol].next=head[u];
     head[u]=tol++;
     edge[tol].from=v;
     edge[tol].to=u;
     edge[tol].cap=;
     edge[tol].next=head[v];
     head[v]=tol++;
 }

 int BFS(int start,int end){
     int que[MAXN];
     int front,rear; front=rear=;
     memset(dep,-,sizeof(dep));
     que[rear++]=start;
     dep[start]=;
     while(front!=rear)    {
         int u=que[front++];
         if(front==MAXN)front=;
         for(int i= head[u];i!=-; i=edge[i].next){
             int v=edge[i].to;
             if(edge[i].cap>&& dep[v]==-){
                 dep[v]=dep[u]+;
                 que[rear++]=v;
                 if(rear>=MAXN) rear=;
                 if(v==end)return ;
             }
         }
     }
     return ;
 }
 int dinic(int start,int end){
     int res=;
     int top;
     int stack[MAXN];
     int cur[MAXN];
     while(BFS(start,end)){
         memcpy(cur,head, sizeof(head));
         int u=start;
         top=;
         while(){
             if(u==end){
                 int min=INF;
                 int loc;
                for(int i=;i<top;i++)
                   if(min>edge [stack[i]].cap) {
                       min=edge [stack[i]].cap;
                       loc=i;
                   }
                 for(int i=;i<top;i++){
                     edge[stack[i]].cap-=min;
                     edge[stack[i]^].cap+=min;
                 }
                 res+=min;
                 top=loc;
                 u=edge[stack[top]].from;
             }
             for(int i=cur[u]; i!=-; cur[u]=i=edge[i].next)
               if(edge[i].cap!= && dep[u]+==dep[edge[i].to])
                  break;
             if(cur[u] !=-){
                 stack [top++]= cur[u];
                 u=edge[cur[u]].to;
             }
             else{
                 if(top==) break;
                 dep[u]=-;
                 u= edge[stack [--top] ].from;
             }
         }
     }
     return res;
 }