最大流之Ford-Fulkerson算法

核心：通过DFS寻找增广路，直至没有增广路，此时的F即为最大流；

操作实质：正向流量流多少，正向容量减多少，反向容量增多少；

下述代码为Ford-Fulkerson算法的邻接表实现，为了方便直接改变c(e)的值，而没有保存f(e)的值；

代码：

//用于表示边的结构体（终点，容量，反向边）
struct edge
{  
        int to,cap,rev;
};

vector<edge> G[max_v];//图的邻接表表示
bool used[max_v];//DFS中用到的访问标记

//向图中增加一条从s到t容量为cap的边
void add_edge(int from,int to,int cap)
{
         G[from].push_back((edge){to,cap,G[to].size()});
         G[to].push_back((edge){from,0,G[from].size()-1});
}

//通过DFS寻找增广路
int dfs(int v,int t,int f)
{
         if(v==t)      return f;
         used[v]=true;
         for(int i=0;i<G[v].size();i++)
         {
                  edge &e=G[v][i];
                  if(!used[e.to]&&e.cap>0)
                  {
                            int d=dfs(e.to,t,min(f,e.cap));
                            if(d>0)
                            {
                                       e.cap-=d;
                                       G[e.to][e.rev].cap+=d;
                                       return d;
                             }
                   }
           }
           return 0;
}

//求解从s到t的最大流
int max_flow(int s,int t)
{
          int flow=0;
          for(;;)
          {
                   memset(used,0,sizeof(used));
                   int f=dfs(s,t,INF);
                   if(f==0)     return flow;
                   flow+=f;
           }
}