Алгоритмы на графах / flows / MAXFLOW

//----------------------------------------------------------------------------------------------    
#include <iostream> 
typedef unsigned int WORD ; 

using namespace std ; 

const MaxN = 101 ; 

struct List { 
   List (){} ; 
   List ( int _V , List * _next ) { V = _V ; next =  _next ;} 
   List * next  ; 
   int V ; 
}; 

int    e[MaxN];            // €§Ўлв®Є 
int    h[MaxN];            // ‚лб®в  ўҐаиЁ­л 
int    f[MaxN][MaxN];         // ’ҐЄг饥 §­ зҐ­ЁҐ ЇаҐ¤Ї®в®Є  
int    c[MaxN][MaxN];         // Џа®ЇгбЄ­лҐ бЇ®б®Ў­®б⨠ॡҐа 

//List L ;               // ўбҐ ўҐа­Ё­л V[G]\{s,t} 
//List N[MaxN] ;            // бЇЁб®Є бўп§­®бвЁ     
List *head[MaxN] , *current[MaxN] , *headL , *pre; 

int  n , m , s = 1,  t , minH ;      // s -  Ёбв®Є , t- бв®Є 

//----------------------------------------------------------------------------------------------    
 void ConstructL(){            // ‚ бЇЁбЄҐ L  еа ­пвбп ўбҐ ўҐаиЁ­л Єа®¬Ґ s,t 
               // в.Ґ V[G]\{s,t} 
      List *cur  ; 
      List * t = new List (2 , NULL ); 
      pre = headL = t ; cur = t ; 
      for (int i = 3 ; i < n ; i++ ) 
      { 
         List *t  = new List ( i , NULL) ; 
         cur->next = t ; 
         cur = cur->next ; 
      } 
 } 
//----------------------------------------------------------------------------------------------    
 int min (int a , int b ){ 
    return a<b ? a:b ; 
 } 
//----------------------------------------------------------------------------------------------                                       // ЇҐаҐ¬Ґй Ґ¬ ўҐаиЁ­г ў ­ з «® 
 void MoveToFront ( List *u ) { 
    
   if ( pre == u )return ; 

   pre->next = u->next ; 

   List * t = new List (u->V , headL ) ; 
   pre = headL = t ; 

   delete u ;       
 } 
//----------------------------------------------------------------------------------------------    
               // €­ЁжЁ «Ё§Ёа㥬 ЇаҐ¤Ї®в®Є 
 void Initilize_PreFlow () {    
               // §¤Ґбм ­¤Ґобм ўбс Ї®­пв­® 
    h[s] = n ; 
    for (int u = 1 ; u <= n ; u++ ){ 
       if ( c[s][u] > 0 ){ 
          f[s][u] =  c[s][u] ; 
          f[u][s] = -c[s][u] ; 
          e[u] = c[s][u]; 
       } 
    } 
 } 
//----------------------------------------------------------------------------------------------                               
               // Џа®в «ЄЁў Ґ¬ Ї®в®Є в.Ґ ў ўҐаиЁ­Ґ u Ґбвм Ё§Ўлв®Є 
 void Push (int u , int v ){         // Ё ­ ¬ ­ ¤® Їа®в®«Є­гвм Ї®в®Є ¤ «миҐ 

    int d = min (e[u] , c[u][v]-f[u][v]); 
    
    f[u][v] =  f[u][v] + d ;        // 㢥«ЁзЁў Ґ¬ Ї®в®Є Ї® ॡаг (u,v) 
    f[v][u] = -f[u][v] ; 

    e[u] = e[u] - d ;             
    e[v] = e[v] + d ; 
 } 
 //----------------------------------------------------------------------------------------------    
                 //  Ї®¤­Ё¬ Ґ¬ ўҐаиЁ­г зв®Ў Їа®в®«Є­гв Ї®в®Є 
 void Lift ( int u ) {              //  в.Є Їа®в «ЄЁў вм ¬®¦­® в®«мЄ® Ё§ ўҐиЁ­ Ў®«м襩 ўлб®вл 
    minH = 100000 ; 
   List *v = head[u];           //Їа®б¬ ваЁў Ґ¬ ўбҐ ўҐаиЁ­л ў ®бв в®з­®© бҐвЁ Ё Ї®¤­Ё¬ Ґ¬ ¤ ­го 
   while (v){              // в Є зв®Ў ®­  бв «  ­  1 ўлиҐ б ¬®© ­Ё§Є®© 
      if (minH > h[v->V] && c[u][v->V]-f[u][v->V] > 0 )minH = h[v->V]; 
      v =  v->next ; 
   } 
   h[u] = ( minH +1 ) ; 
 } 
//----------------------------------------------------------------------------------------------    
 void Discharge ( int u ){         // а §Јаг§Є  ўҐаиЁ­л 
    while ( e[u] > 0 ){         // ­®Є  Ґбвм Ё§Ўлв®Є        
       List* v = current[u]; 
       if ( current[u] == NULL ){ 
          Lift ( u );            // Ї®¤­Ё¬ Ґ¬ ўҐаиЁ­г 
          current[u] = head[u]; 
       }                                                                   
       else if ( c[u][v->V]-f[u][v->V] > 0 && h[u] == h[v->V] + 1) 
          Push (u , v->V );      // ­ и«Ё ¤®ЇгбвЁ¬®Ґ ॡ஠Ё Їа®в®«Є­г«Ё Ї®в®Є 
       else current[u] = current[u]->next ;   // ЇҐаҐе®¤Ё¬ Є б«Ґ¤го饬г н«Ґ¬Ґ­вг 
    } 
 } 
//----------------------------------------------------------------------------------------------    
 void Lift_To_Front (){ 

   Initilize_PreFlow() ;          // ”®а¬Ёа㥬 ­ з «м­лҐ ЇаҐ¤Ї®в®Є 
   ConstructL() ; 

   for (int i = 2 ; i < n ; i++ )       // s == 1 , t == n 
      current[i] = head[i]; 

   List *u = headL ; 

   while ( u != NULL ){                
      int old_height  = h[u->V]; 

      Discharge( u->V );       // ђ §Јаг¦ Ґ¬ ўҐаиЁ­г u 

      if ( h[u->V] > old_height ){    // Ґб«Ё ўҐаиЁ­  Ўл«® Ї®¤­пв  в® 
         MoveToFront ( u );   // ЇҐаҐ¬Ґй Ґ¬ Ґс ў ­ з «® бЇЁбЄ  
         u = headL; 
      } 
      pre = u ; 
      u = u->next ;       // ЇҐаҐе®¤Ё¬ Є б«Ґ¤го饩 ўҐаиЁ­Ґ 
   } 
   // ЇаЁ ўл室Ґ Ё§ Їа®жҐ¤гал ўбҐ ®ЎкҐЄвл ᮧ¤ ­лҐ ®ЇҐа в®а new ­ ¤® 
   // г¤ «Ёвм §  ­Ґ ­ ¤®Ў­®бвмо , ¬­Ґ ў«®¬ ®бв ў«по нв® ў ¬ :) 
 } 
//------------------------------------------------------------------------------------------------ 
 int main () { 
    
   cin >> n >> m ;         // §¤Ґбм n - Є®«ЁзҐбвў® ўҐаиЁ­ m - Є®«ЁзҐбвў® асЎҐа 
   int a , b , cf ;         // ..Їа®ЇгбЄ­ п бЇ®б®Ў­®бвм аҐЎа  (a,b) == cf 
   for (int i = 0 ; i < m ; i++ ) 
   { 
       cin >> a >> b >> cf ; 
       c[a][b] = cf; 
   } 
               //.. ¤«п Є ¦¤®© ўҐаиЁ­л u т V бва®Ё¬ ®¤­®бв®а®­Ё© бЇЁб®Є 
    for (int i = 1 ; i <= n ; i++ ){        // б®бҐ¤Ґс ўҐаиЁ­  v ­ е®¤Ёвбп ў н⮬ бЇЁбЄҐ Ґ«Ё 
       List *cur ;      // (u,v) т E «Ё« (v,u) т E 
       int w = 0 ; 
       for (int j = 1 ; j <= n ; j ++ ){ 
          if ( c[i][j] > 0 || c[j][i] > 0 ){ 
            List * t = new List( j , NULL ) ; 
            if (!w){ 
               head[i] = t ; 
               cur = t ; 
               w = 1 ; 
            } 
            else { 
               cur->next = t ; 
               cur = cur->next ; 
            } 
          }                    
       } 
    } 

Lift_To_Front (); 
               // ў ¬ бЁўҐ f Ё¬ҐҐ¬ Ї®в®Є 
int sum = 0 ; 
for (int i = 1 ; i <= n ; i++ ) 
   sum +=  f[i][n]; 

   cout << sum ; 
    return 0 ; 
 } 
 //------------------------------------------------------------------------------------------------