最大流 Dinic

 struct Dinic
 {
       struct node
       {
              int x,y,c,next;
       }line[MAXM];
       int Lnum,_next[MAXN],dis[MAXN],dp[MAXN];
       bool inqueue[MAXN];
       void initial(int n)
       {
              for (int i=;i<=n;i++) _next[i]=-;
              Lnum=-;
       }
       void addline(int x,int y,int c)
       {
              line[++Lnum].next=_next[x],_next[x]=Lnum;
              line[Lnum].x=x,line[Lnum].y=y,line[Lnum].c=c;
              line[++Lnum].next=_next[y],_next[y]=Lnum;
              line[Lnum].x=y,line[Lnum].y=x,line[Lnum].c=;
       }
       bool BFS(int s,int e)
       {
              queue<int> Q;
              while (!Q.empty()) Q.pop();
              memset(dis,,sizeof(dis));
              dis[s]=,Q.push(s);
              while (!Q.empty())
              {
                    int h,k;
                    h=Q.front(),Q.pop();
                    if (h==e) return dis[e];
                    for (k=_next[h];k!=-;k=line[k].next)
                       if (line[k].c && !dis[line[k].y])
                          dis[line[k].y]=dis[h]+,Q.push(line[k].y);
              }
              return false;
       }
       int dfs(int x,int flow,int e)
       {
              if (x==e) return flow;
              int temp,cost=;
              for (int k=_next[x];k!=-;k=line[k].next)
              if (line[k].c && dis[line[k].y]==dis[x]+)
              {
                     temp=dfs(line[k].y,min(flow-cost,line[k].c),e);
                     if (temp)
                     {
                            line[k].c-=temp,line[k^].c+=temp;
                            cost+=temp;
                            if (flow==cost) return cost;
                     }else dis[line[k].y]=-;
              }
              return cost;
       }
       int MaxFlow(int s,int e)
       {
              int MaxFlow=;
              while (BFS(s,e)) MaxFlow+=dfs(s,oo,e);
              return MaxFlow;
       }
 }T;

每次调用之前都要初始化 T.initial(最多节点);