UVA10480 Sabotage —— 最小割最大流

题目链接：https://vjudge.net/problem/UVA-10480

题解：

实际就是求最小割集。

1.什么是网络流图的“割”？答：一个边的集合，使得网络流图删除这些边之后，点被分成两部分S和T， 且源点位于S中， 汇点位于T中。注意：不能存在独立于S和T的点。

2.对于最小割集中的边，它在残余网络中容量为0。

3.从源点出发，沿着有残余容量的边走，能够访问到的点都属于S集合，否则属于T集合。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int mod = 1e9+;
 const int MAXN = 1e2+;

 int maze[MAXN][MAXN];
 int gap[MAXN], dis[MAXN], pre[MAXN], cur[MAXN];
 int flow[MAXN][MAXN];

 int sap(int start, int end, int nodenum)
 {
     memset(cur, , sizeof(cur));
     memset(dis, , sizeof(dis));
     memset(gap, , sizeof(gap));
     memset(flow, , sizeof(flow));
     int u = pre[start] = start, maxflow = , aug = INF;
     gap[] = nodenum;

     while(dis[start]<nodenum)
     {
         loop:
         for(int v = cur[u]; v<nodenum; v++)
         if(maze[u][v]-flow[u][v]> && dis[u] == dis[v]+)
         {
             aug = min(aug, maze[u][v]-flow[u][v]);
             pre[v] = u;
             u = cur[u] = v;
             if(v==end)
             {
                 maxflow += aug;
                 for(u = pre[u]; v!=start; v = u, u = pre[u])
                 {
                     flow[u][v] += aug;
                     flow[v][u] -= aug;
                 }
                 aug = INF;
             }
             goto loop;
         }

         int mindis = nodenum-;
         for(int v = ; v<nodenum; v++)
             if(maze[u][v]-flow[u][v]> && mindis>dis[v])
             {
                 cur[u] = v;
                 mindis = dis[v];
             }
         if((--gap[dis[u]])==) break;
         gap[dis[u]=mindis+]++;
         u = pre[u];
     }
     return maxflow;
 }

 bool vis[MAXN];
 void dfs(int u, int n)
 {
     vis[u] = true;
     for(int v = ; v<n; v++)
         if(maze[u][v]-flow[u][v] && !vis[v])
             dfs(v, n);
 }

 int edge[MAXN*MAXN][];
 int main()
 {
     int n, m;
     while(scanf("%d%d", &n, &m)&&(n||m))
     {
         memset(maze, , sizeof(maze));
         for(int i = ; i<=m; i++)
         {
             int u, v, w;
             scanf("%d%d%d", &u,&v,&w);
             edge[i][] = --u; edge[i][] = --v;
             maze[u][v] = w;
             maze[v][u] = w;
         }

         int start = , end = ;
         sap(start, end, n);

         memset(vis, false, sizeof(vis));
         dfs(, n);
         for(int i = ; i<=m; i++)
         {
             int u = edge[i][];
             int v = edge[i][];
             if( (vis[u] && !vis[v]) || (!vis[u] && vis[v]) )
                 printf("%d %d\n", u+, v+);
         }
         printf("\n");
     }
 }