zoj 3229 上下界网络最大可行流带输出方案

收获:

1. 上下界网络流求最大流步骤:

　　1) 建出无环无汇的网络,并看是否存在可行流

　　2) 如果存在,那么以原来的源汇跑一次最大流

　　3) 流量下界加上当前网络每条边的流量就是最大可行流了.

2. 输出方案:

　　可以把边的位置信息一起存在边表中,求完最大流后遍历一下边,把信息更新过去.

 #include <cstdio>
 #include <cstring>
 #define min(a,b) ((a)<(b)?(a):(b))
 #define oo 0x3f3f3f3f
 #define N 1500
 #define M 500000

 struct Dinic {
     int n, src, dst;
     int head[N], dest[M], flow[M], next[M], info[M][], etot;
     int cur[N], dep[N], qu[N], bg, ed;
     void init( int n, int src, int dst ) {
         this->n = n;
         this->src = src;
         this->dst = dst;
         etot = ;
         memset( head, -, sizeof(head) );
     }
     void adde( int i, int j, int u, int v, int f ) {
         next[etot]=head[u],flow[etot]=f,dest[etot]=v,info[etot][]=i,info[etot][]=j; head[u]=etot++;
         next[etot]=head[v],flow[etot]=,dest[etot]=u,info[etot][]=-,info[etot][]=-; head[v]=etot++;
     }
     bool bfs() {
         memset( dep, , sizeof(dep) );
         qu[bg=ed=] = src;
         dep[src] = ;
         while( bg<=ed ) {
             int u=qu[bg++];
             for( int t=head[u]; t!=-; t=next[t] ) {
                 int v=dest[t], f=flow[t];
                 if( f && !dep[v] ) {
                     dep[v] = dep[u]+;
                     qu[++ed] = v;
                 }
             }
         }
         return dep[dst];
     }
     int dfs( int u, int a ) {
         if( u==dst || a== ) return a;
         int remain=a, past=, na;
         for( int &t=cur[u]; t!=-; t=next[t] ) {
             int v=dest[t], &f=flow[t], &vf=flow[t^];
             if( f && dep[v]==dep[u]+ && (na=dfs(v,min(remain,f))) ) {
                 f -= na;
                 vf += na;
                 remain -= na;
                 past += na;
                 if( !remain ) break;
             }
         }
         return past;
     }
     int maxflow() {
         int f=;
         while( bfs() ) {
             memcpy( cur, head, sizeof(cur) );
             f += dfs(src,oo);
         }
         return f;
     }
 }D;
 struct Btop {
     int n;
     int head[N], dest[M], bval[M], tval[M], next[M], info[M][], etot;
     int si[N], so[N];
     void init( int n ) {
         this->n = n;
         etot = ;
         memset( head, -, sizeof(head) );
         memset( si, , sizeof(si) );
         memset( so, , sizeof(so) );
     }
     void adde( int i, int j, int u, int v, int b, int t ) {
         next[etot]=head[u],tval[etot]=t,bval[etot]=b,dest[etot]=v;
         info[etot][]=i, info[etot][]=j;
         si[v] += b, so[u] += b;
         head[u]=etot++;
     }
     bool ok() {
         int src=n+, dst=n+;
         D.init( dst, src, dst );
         for( int u=; u<=n; u++ )
             for( int t=head[u]; t!=-; t=next[t] ) {
                 int v=dest[t];
                 D.adde( info[t][], info[t][], u, v, tval[t]-bval[t] );
             }
         int sum = ;
         for( int u=; u<=n; u++ ) {
             if( si[u]>so[u] ) {
                 D.adde( -, -, src, u, si[u]-so[u] );
                 sum += si[u]-so[u];
             } else if( so[u]>si[u] ) {
                 D.adde( -, -, u, dst, so[u]-si[u] );
             }
         }
         return sum==D.maxflow();
     }
 }B;

 int n, m;
 int c[];
 int ans[][], tot;

 int main() {
     while( scanf( "%d%d", &n, &m ) ==  ) {
         int src=n+m+, dst=src+;
         B.init(dst);
         for( int i=,g; i<=m; i++ ) {
             scanf( "%d", &g );
             B.adde( -, -, n+i, dst, g, oo );
         }
         memset( ans, , sizeof(ans) );
         tot = ;
         for( int i=,d; i<=n; i++ ) {
             scanf( "%d%d", c+i, &d );
             B.adde( -, -, src, i, , d );
             for( int j=,t,l,r; j<=c[i]; j++ ) {
                 scanf( "%d%d%d", &t, &l, &r );
                 t++;
                 B.adde( i, j, i, n+t, l, r );
                 ans[i][j] = l;
                 tot += l;
             }
         }
         B.adde( -, -, dst, src, , oo );
         bool ok = B.ok();
         if( !ok ) {
             printf( "-1\n" );
         } else {
             D.src=src;
             D.dst=dst;
             D.maxflow();
             for( int t=; t<D.etot; t++ ) {
                 int i=D.info[t][], j=D.info[t][];
                 if( ~i && ~j ) {
                     ans[i][j] += D.flow[t^];
                     tot += D.flow[t^];
                 }
             }
             printf( "%d\n", tot );
             for( int i=; i<=n; i++ )
                 for( int j=; j<=c[i]; j++ )
                     printf( "%d\n", ans[i][j] );
         }
         printf( "\n" );
     }
 }