zoj 2587 判断最小割的唯一性

算法：

　　先求出残量网络，计算出从src能够到的点集A，再求出能够到dst的点集B，如果所有点都被访问到了，那么割就是唯一的，即(A,B)，否则(A,V-A)和(V-B,B)都是最小割。

　　（注意因为割的本质是有向边集，而不是点集V的划分，所以(A,V-A)和(V-B,B)有可能本质上还是同一个最小割，比如随便再加一个孤立点，虽然割还是唯一的，但还是有点没有被访问到，所以我们限制原图中所有点要么可以从src到达，要么可以到达dst）

 #include <cstdio>
 #include <cstring>
 #include <vector>
 #define N 810
 #define oo 0x3f3f3f3f
 using namespace std;

 struct Edge {
     int u, v, f;
     Edge( int u, int v, int f ):u(u),v(v),f(f){}
 };
 int n, m, src, dst;
 vector<Edge> edge;
 vector<int> g[N];
 int dep[N], cur[N], qu[N], bg, ed;
 bool vis[N];

 void init( int n ) {
     edge.clear();
     for( int u=; u<=n; u++ )
         g[u].clear();
 }
 void adde( int u, int v, int f ) {
     g[u].push_back( edge.size() );
     edge.push_back( Edge(u,v,f) );
     g[v].push_back( edge.size() );
     edge.push_back( Edge(v,u,) );
 }
 bool bfs() {
     memset( dep, , sizeof(dep) );
     qu[bg=ed=] = src;
     dep[src] = ;
     while( bg<=ed ) {
         int u=qu[bg++];
         for( int t=; t<g[u].size(); t++ ) {
             Edge &e = edge[g[u][t]];
             if( e.f && !dep[e.v] ) {
                 dep[e.v] = dep[e.u]+;
                 qu[++ed] = e.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<g[u].size(); t++ ) {
         Edge &e=edge[g[u][t]];
         Edge &ve=edge[g[u][t]^];
         if( e.f && dep[e.v]==dep[e.u]+ && (na=dfs(e.v,min(remain,e.f))) ) {
             remain -= na;
             past += na;
             e.f -= na;
             ve.f += na;
             if( !remain ) break;
         }
     }
     return past;
 }
 int maxflow() {
     int flow = ;
     while( bfs() ) {
         memset( cur, , sizeof(cur) );
         flow += dfs(src,oo);
     }
     return flow;
 }
 bool check() {
     int cnt = ;
     memset( vis, , sizeof(vis) );
     qu[bg=ed=] = src;
     vis[src] = true;
     cnt++;
     while( bg<=ed ) {
         int u=qu[bg++];
         for( int t=; t<g[u].size(); t++ ) {
             Edge &e = edge[g[u][t]];
             if( e.f && !vis[e.v] ) {
                 qu[++ed] = e.v;
                 vis[e.v] = true;
                 cnt++;
             }
         }
     }
     qu[bg=ed=] = dst;
     vis[dst] = true;
     cnt++;
     while( bg<=ed ) {
         int u=qu[bg++];
         for( int t=; t<g[u].size(); t++ ) {
             Edge &e = edge[g[u][t]^];
             if( e.f && !vis[e.u] ) {
                 qu[++ed] = e.u;
                 vis[e.u] = true;
                 cnt++;
             }
         }
     }
     return n==cnt;
 }
 int main() {
     while() {
         scanf( "%d%d%d%d", &n, &m, &src, &dst );
         if( n== && m== && src== && dst== ) return ;
         init(n);
         for( int i=,u,v,f; i<=m; i++ ) {
             scanf( "%d%d%d", &u, &v, &f );
             adde( u, v, f );
             adde( v, u, f );
         }
         maxflow();
         printf( "%s\n", check() ? "UNIQUE" : "AMBIGUOUS" );
     }
 }