永远不会被卡的Dinic

78,79行是精髓

61,148,149行是当前弧优化

 #include <cstring>
 #include <cstdio>
 #include <queue>

 #define Max 1000090
 #define INF 1e9

 void read (int &now)
 {
     now = ;
     register char word = getchar ();
     while (word < '' || word > '')
         word = getchar ();
     while (word >= '' && word <= '')
     {
         now = now *  + word - '';
         word = getchar ();
     }
 }

 int N, M, S, T;

 inline int min (int a, int b)
 {
     return a < b ? a : b;
 }

 class Net_Flow_Type
 {

     private :

         int __to[Max * ];
         int __next[Max * ];

         int __flow[Max * ];

         int Edge_Count;
         int edge_list[Max];

         int deep[Max], Answer;

         int Queue[Max * ];
         int Head, Tail;
         int __tech_[Max];

     public :

         Net_Flow_Type ()
         {
             Edge_Count = ;
             Answer = ;
         }

         int Flowing (int now, int flow)
         {
             if (flow <=  || now == T)
                 return flow;
             int pos = , res;

             for (int &i = __tech_[now]; i; i = __next[i])
             {
                 if (deep[__to[i]] != deep[now] +  || __flow[i] <= )
                     continue;
                 res = Flowing (__to[i], std :: min (flow, __flow[i]));
                 if (res > )
                 {
                     flow -= res;
                     pos += res;

                     __flow[i] -= res;
                     __flow[i ^ ] += res;

                     if (flow <= )
                         return pos;
                 }
             }
             if (pos != flow)
                 deep[now] = -;
             return pos;
         }

         inline void Add_Edge (int from, int to, int flow)
         {
             Edge_Count ++;
             __to[Edge_Count] = to;

             __next[Edge_Count] = edge_list[from];
             edge_list[from] = Edge_Count;

             Edge_Count ++;
             __to[Edge_Count] = from;

             __next[Edge_Count] = edge_list[to];
             edge_list[to] = Edge_Count;

             __flow[Edge_Count - ] = flow;
             __flow[Edge_Count] = ;

         }

         void Insert_edges ()
         {
             for (int i = , from, to, flow; i <= M; i ++)
             {
                 read (from);
                 read (to);
                 read (flow);

                 this->Add_Edge (from, to, flow);
             }
         }

         bool Bfs (int Start)
         {

             for (int i = ; i <= N; i ++)
                 deep[i] = -;
             Head = , Tail = ;
             Queue[Head] = Start;

             deep[Start] = ;
             register int now;

             while (Head < Tail)
             {
                 now = Queue[Head];
                 Head ++;

                 for (int i = edge_list[now]; i; i = __next[i])
                     if (deep[__to[i]] == - && __flow[i])
                     {
                         deep[__to[i]] = deep[now] + ;
                         if (__to[i] == T)
                             return true;

                         Queue[Tail ++] = __to[i];
                     }
             }

             return deep[T] != -;
         }

         int Dinic ()
         {
             while (Bfs (S))
             {
                 for (int i = ; i <= N; i ++)
                     __tech_[i] = edge_list[i];

                 Answer += Flowing (S, INF);
             }

             return Answer;
         }
 };

 Net_Flow_Type Make;

 int main (int argc, char *argv[])
 {
     read (N);
     read (M);
     read (S);
     read (T);

     Make.Insert_edges (); 

     printf ("%d", Make.Dinic ());

     return ;
 }