最大流加强 dinic+当前弧优化

qyy开始练习网络流啦 ， 啊 ，蒟蒻只会套版 ，很裸的题 ， 我连题都不想发了 ，可以参考我的代码（虽然我也是看的别人的

 #include <iostream>
 #include <cstring>
 #include <vector>
 #include <cstdio>
 #include <queue>
 const int N =  +  , M =  +  ;
 using namespace std ;
 int  n , m  ;
 int tot , head[N] ;
 long long ans;
 struct id
 {
     int to , nxt ;
     long  long val ;
 } edge[M<<] ;
 queue< int > Q;
 int dis[N] ,cur[N]; 

 inline void  Init( )
 {
     freopen( "NSOOJ10477.in" , "r" , stdin ) ;
     freopen( "NSOOJ10477.out" , "w" , stdout ) ;
 }

 int read(  )
 {
     char ch = getchar(  ) ; int k =  , ret =  ;
     while( ch > '' || ch < '' ) { if( ch == '-' ) k = - ; ch = getchar( ) ; }
     while( ch <= '' && ch >= '' ) ret = ret *  + ch - '' , ch = getchar( ) ;
     return ret * k ;
 }

 void add( int u , int v , int c )
 {
     edge[++tot].to = v , edge[tot].nxt = head[u] ;
     edge[tot].val = c , head[u] = tot ;
 }

 void input(  )
 {
     n = read( ) , m = read( ) ;
     memset( head , - , sizeof( head ) ) ;
     tot =  ;
     for( int x =  ; x <= m ; ++x  )
     {
         int a, b , c ;
         a = read( ) , b = read( ) , c = read( ) ;
         add( a, b , c ) ;
         add( b , a ,  ) ;
     }
 }

 bool bfs(  )
 {
     memset( dis , - , sizeof(dis) ) ;
     Q.push(  ) ; dis[] =  ;
     while( !Q.empty( ) )
     {
         int u = Q.front( ) ; Q.pop( ) ;
         for( int i = head[u] ; ~i ; i = edge[i].nxt )
         {

             int v = edge[i].to ;
             if( dis[v] <  && edge[i].val >  )
             {
                 dis[v] = dis[u] +  ; Q.push( v ) ;
             }

         }
     }
 //    cout<<endl;
     if( dis[n] >  ) return true ;
     return false ;
 }

 long long int dfs( int u , int inf )
 {
     long long int ans = 0ll , cost = 0ll;
     if( u == n ) return inf ;
     for( int i = cur[u] ; ~i ; i = edge[i].nxt )
     {
         int  v = edge[i].to ;
         if( dis[v] != dis[u] +  ) continue ;
         ans = dfs( v , min( inf - cost , edge[i].val ) ) ;
         edge[i].val -= ans ;
         edge[i^].val += ans ;
         if( edge[i].val ) cur[u] = i ;
         cost += ans ;
         if( cost == inf ) return inf ;
     }
     if( !cost ) dis[u] = - ;
     return  cost ;
 }

 void sov(  )
 {
     ans =  ;
     while( bfs( ) )
     {
         int now ;
         for( int i =  ; i <= n ; ++i ) cur[i] = head[i] ;
         ans += dfs(  , << ) ;
     }
     printf( "%lld" , ans ) ;
 }

 int main(  )
 {
 //    Init( ) ;
     input(  ) ;
     sov( ) ;
 //    fclose( stdin ) ;
 //    fclose( stdout ) ;
     return  ;
 }

重新贴板，和上面的程序几乎没什么区别，码风固定了，值得开心。

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <queue>
 const int N = , M = 3e5 + , inf =  << ;
 using namespace std;
 int n, m, head[N], cnt, dis[N],cur[N];
 queue<int>Q;
 struct edge
 {
     int nxt,to,vi;
 } E[M<<];

 void add(int u,int v,int vi)
 {
     E[++cnt] = (edge){head[u],v,vi}; head[u] = cnt;
     E[++cnt] = (edge){head[v],u,}; head[v] = cnt;
 }

 void Init()
 {
     scanf("%d%d",&n,&m); cnt = -;
     int u,v,vi;
     memset(head,-,sizeof(head));
     for(int i = ; i <= m; ++i)
     {
         scanf("%d%d%d",&u,&v,&vi);
         add(u,v,vi);
     }
 }

 bool bfs()
 {
     memset(dis,-,sizeof(dis));
     Q.push(); dis[] = ;
     while(!Q.empty())
     {
         int u =  Q.front(); Q.pop();
         for(int i = head[u]; ~i; i = E[i].nxt)
         {
             int v = E[i].to;
             if(dis[v] == - && E[i].vi > ) dis[v] = dis[u] + , Q.push(v);
         }
     }
     return (dis[n] > );
 }

 int dfs(int u,int t,int ff)
 {
     int ret = , cost = ;
     if(u == t) return ff;
     for(int i = cur[u] ; ~i; i = E[i].nxt)
     {
         int v = E[i].to;
         if(dis[v] != dis[u] + ) continue;
         cost = dfs(v,t,min(ff-ret,E[i].vi));
         E[i].vi -= cost, E[i^].vi += cost; ret += cost;
         if(E[i].vi) cur[u] = i;
         if(ret == ff) return ff;
     }
     if(!ret) dis[u] = -;
     return ret;
 }

 int max_flow(int s,int t)
 {
     int ret = ;
     while(bfs())
     {
         for(int i = ; i <= n; ++i) cur[i] = head[i];
         ret += dfs(s,t,inf);
     }
     return ret;
 }

 void Solve()
 {
     int ans = max_flow(,n);
     printf("%d\n",ans);
 }

 int main()
 {
     Init();
     Solve();

     return ;
 }