網絡流

1. 最大流

• FF

  struct edge
  {
  int from, to, cap, flow;//分別是起點，終點，容量，流量
  edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f){}
  };
  int n, m;//n爲點數，m爲邊數
  vector<edge>e;//保存所有邊的信息
  vector<int>G[maxn];//鄰接表，G[i][j]保存節點i的第j條邊在e數組裏面的編號
  int a[maxn];//每個點目前流經的水量
  int p[maxn];//p[i]從原點s到終點t的節點i的前一條邊的編號
  void init(int n)
  {
  for(int i = 0; i <= n; i++)G[i].clear();
  e.clear();
  }
  void addedge(int u, int v, int c)
  {
  e.push_back(edge(u, v, c, 0));//正向邊
  e.push_back(edge(v, u, 0, 0));//反向邊，容量爲0
  m = e.size();
  G[u].push_back(m - 2);
  G[v].push_back(m - 1);
  }
  int Maxflow(int s, int t)//起點爲s，終點爲t
  {
  int flow = 0;
  for(;;)
  {
      memset(a, 0, sizeof(a));//從原點s開始放水，最初每個點的水量都爲0
      queue<int>Q;//BFS拓展隊列
      Q.push(s);
      a[s] = INF;//原點的水設置成INF
      while(!Q.empty())
      {
          int x = Q.front();//取出目前水流到的節點
          Q.pop();
          for(int i = 0; i < G[x].size(); i++)//所有鄰接節點
          {
              edge& now = e[G[x][i]];
              if(!a[now.to] && now.cap > now.flow)
                  //a[i]爲0表示i點還未流到
                  //now.cap > now.flow 說明這條路還沒流滿
                  //同時滿足這兩個條件，水流可以流過這條路
              {
                  p[now.to] = G[x][i];//反向記錄路徑
                  a[now.to] = min(a[x], now.cap - now.flow);
                  //流到下一點的水量爲上一點的水量或者路徑上還可以流的最大流量，這兩者取最小值
                  Q.push(now.to);//將下一個節點入隊列
              }
          }
          if(a[t])break;//如果已經流到了終點t，退出本次找增廣路
      }
      if(!a[t])break;//如果所有路都已經試過，水不能流到終點，說明已經沒有增廣路，已經是最大流
      for(int u = t; u != s; u = e[p[u]].from)//反向記錄路徑
      {
          e[p[u]].flow += a[t];//路徑上所有正向邊的流量增加流到終點的流量
          e[p[u]^1].flow -= a[t];//路徑上所有反向邊的流量減少流到終點的流量
      }
      flow += a[t];//最大流加上本次流到終點的流量
  }
  return flow;
  }

• Dinic

  #include<bits/stdc++.h>
  #define me(a,x) memset(a,x,sizeof(a))
  using namespace std;
  typedef long long ll;
  typedef unsigned long long ull;
  const int mod=1e9+7;
  const int N=2e5+5;
  const int MAX=0x7fffffff;
  const int MIN=0x80000000;
  struct Edge{int to,dis,next;}edges[N];
  int head[N],edge_num=0;
  int n,m,s,t;
  int d[N];//層次  源點到i點的長度
  void add_edge(int from,int to,int dis){
  edges[edge_num]={to,dis,head[from]};
  head[from]=edge_num++;
  }
  int DFS(int u,int flow){
  if(u==t)return flow;
  int sum=0,increase;
  for(int i=head[u];~i;i=edges[i].next){
      int v=edges[i].to;
      if(d[v]==d[u]+1 and edges[i].dis>0){
          increase=DFS(v,min(flow,edges[i].dis));
          flow-=increase;
          sum+=increase;
          edges[i].dis-=increase;
          edges[i^1].dis+=increase; 
          if(flow==0)break;
      }
  }
  return sum;
  }
  bool BFS(){
  me(d,-1);
  queue<int>Q;
  d[s]=0;
  Q.push(s);
  while(!Q.empty()){
      int now=Q.front();
      Q.pop();
      for(int i=head[now];~i;i=edges[i].next){
          int v=edges[i].to;
          if(d[v]==-1 and edges[i].dis>0){
              d[v]=d[now]+1;
              Q.push(v);
          }
      }
  }
  return d[t]^-1;
  }
  int DINIC(){
  int max_flow=0;
  while(BFS())max_flow+=DFS(s,MAX);
  return max_flow;
  }
  int main(){
  me(head,-1);
  cin>>n>>m>>s>>t;
  for(int i=0;i<m;i++){
      int u,v,dis;
      cin>>u>>v>>dis;
      add_edge(u,v,dis);
      add_edge(v,u,0);
  }
  printf("%d\n",DINIC());
  }