Flow Problem

Problem Description

Network flow is a well-known difficult problem for ACMers. Given a graph, your task is to find out the maximum flow for the weighted directed graph.

 

Input

The first line of input contains an integer T, denoting the number of test cases. For each test case, the first line contains two integers N and M, denoting the number of vertexes and edges in the graph. (2 <= N <= 15, 0 <= M <= 1000) Next M lines, each line contains three integers X, Y and C, there is an edge from X to Y and the capacity of it is C. (1 <= X, Y <= N, 1 <= C <= 1000)

 

Output

For each test cases, you should output the maximum flow from source 1 to sink N.

Sample Input

2

3 2

1 2 1

2 3 1

3 3

1 2 1

2 3 1

1 3 1

 

Sample Output

Case 1: 1

Case 2: 2

*********************************************************************************************

网络流 纯的sap算法。（用递归）

*********************************************************************************************

#include<iostream>
#include<string>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<vector>
#include<stack>
#define  inf   0x3fffffff
using namespace std;
int lvl[2020],gap[2020],idx,source,sink,n,m,head[2020];
int T;
int min(int a,int b)
 {
     return a>b?b:a;
 }
struct nodedge
 {
     int next;
     int to;
     int cap;
 }e[2020];
 int i,j,k,num;
 void  add(int a,int b,int c)//加边，正向&&反向
  {
      e[num].cap=c;
      e[num].to=b;
      e[num].next=head[a];
      head[a]=num;
      num++;
      e[num].cap=0;
      e[num].to=a;
      e[num].next=head[b];
      head[b]=num;
      num++;
  }
  int dfs(int src,int aug)
   {
       if(src==sink)//到汇点返回
        return aug;
       int tf=0,sf,mlvl=n-1;
       for(int it=head[src];it!=-1;it=e[it].next)//链式前向星
        {
            if(e[it].cap>0)//边仍然有容量
             {
                 if(lvl[src]==lvl[e[it].to]+1)//判断是否为最短边
                   {
                       sf=dfs(e[it].to,min(aug-tf,e[it].cap));//向下递归，到汇点时的值
                        e[it].cap-=sf;
                        e[it^1].cap+=sf;//反向加
                        tf+=sf;//与流入节点的最大流量比较

                    if(lvl[source]>=n)//如果节点的层数大于最大返回（注意是反向的）
                     return tf;
                    if(tf==aug)//等于最大流量时返回
                     break;
                    }
                  mlvl=min(mlvl,lvl[e[it].to]);//求最近边
             }
        }
        if(tf==0)//出现断层时
        {
         --gap[lvl[src]];
         if(gap[lvl[src]]==0)
          lvl[source]=n;
          else
           {
               lvl[src]=mlvl+1;
                gap[lvl[src]]++;
           }

        }
    return tf;
   }
  int sap()
  {
      int ans=0;
      gap[0]=n;
      while(lvl[source]<n)
       ans+=dfs(source,inf);
      return ans;
  }
  int main()
  {
    cin>>T;
    int st,en,c,ps=0;
    while(T--)
     {
         ps++;
         memset(lvl,0,sizeof(lvl));
         memset(gap,0,sizeof(gap));
         memset(head,-1,sizeof(head));
         cin>>n>>m;
         num=0;
         for(i=1;i<=m;i++)
          {
              cin>>st>>en>>c;
              add(st,en,c);
          }
        sink=n;source=1;
        cout<<"Case "<<ps<<": "<<sap()<<endl;
     }
  }

奋进