UVa 1440：Inspection（带下界的最小流）***

https://vjudge.net/problem/UVA-1440

题意：给出一个图，要求每条边都必须至少走一次，问最少需要一笔画多少次。

思路：看了好久才勉强看懂模板。良心推荐：学习地址。

看完这个大概就能懂了。

那条T->S的边的反向边的流量就是可行流的流量。
最小流就是去掉新的源点和新的汇点（保证必要弧）和T->S边后，从T往S跑最大流（尽量退流），最小流的答案就是原来T->S的反向边流量 - 第二次最大流的流量。
最大流就是去掉新的源点和新的汇点之后，再跑一遍最大流得到的就是答案。

最小流这里后面看别人的发现别人是先跑一遍（SS->ST）最大流，然后再连<T,S>边，再跑一遍（SS->ST）最大流。然而论文里面是先连<T,S>边，跑一遍（SS->ST）最大流，然后删掉<T,S>边和所有与SS、ST相连的边，跑一遍（T->S）的最大流。

看了N久还是不能完全理解。

记得多组数组！！！WA了一晚上。

写法一：

 #include <bits/stdc++.h>
 using namespace std;
 #define N 210
 #define INF 0x3f3f3f3f
 struct Edge {
     int u, v, nxt, cap;
 } edge[N*N];
 int head[N], tot, dis[N], cur[N], pre[N], gap[N], in[N], out[N], S, T, SS, ST;

 void Add(int u, int v, int cap) {
     edge[tot].u = u, edge[tot].v = v, edge[tot].nxt = head[u], edge[tot].cap = cap, head[u] = tot++;
     edge[tot].u = v, edge[tot].v = u, edge[tot].nxt = head[v], edge[tot].cap = , head[v] = tot++;
 }

 int BFS(int T) {
     memset(dis, INF, sizeof(dis));
     memset(gap, , sizeof(gap));
     memcpy(cur, head, sizeof(cur));
     dis[T] = , gap[]++;
     queue<int> que; que.push(T);
     while(!que.empty()) {
         int u = que.front(); que.pop();
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v;
             if(dis[v] == INF) {
                 dis[v] = dis[u] + ;
                 gap[dis[v]]++;
                 que.push(v);
             }
         }
     }
 }

 int ISAP(int S, int T, int n) {
     BFS(T);
     int u = pre[S] = S, i, index, flow, ans = ;
     while(dis[S] < n) {
         if(u == T) {
             flow = INF;
             for(i = S; i != T; i = edge[cur[i]].v)
                 if(flow > edge[cur[i]].cap) flow = edge[cur[i]].cap, index = i;
             for(i = S; i != T; i = edge[cur[i]].v)
                 edge[cur[i]].cap -= flow, edge[cur[i]^].cap += flow;
             ans += flow, u = index;
         }
         for(i = cur[u]; ~i; i = edge[i].nxt) if(edge[i].cap && dis[edge[i].v] +  == dis[u]) break;
         if(~i) {
             cur[u] = i; pre[edge[i].v] = u; u = edge[i].v;
         } else {
             if(--gap[dis[u]] == ) break;
             int md = n;
             for(int i = head[u]; ~i; i = edge[i].nxt)
                 if(edge[i].cap && dis[edge[i].v] < md) md = dis[edge[i].v], cur[u] = i;
             gap[dis[u] = md + ]++;
             u = pre[u];
         }
     }
     return ans;
 }

 void Delete() {
     for(int i = head[SS]; ~i; i = edge[i].nxt) edge[i].cap = edge[i^].cap = ;
     for(int i = head[ST]; ~i; i = edge[i].nxt) edge[i].cap = edge[i^].cap = ;
     edge[tot-].cap = edge[(tot-)^].cap = ;
 }

 void Update(int n) {
     for(int u = ; u <= n; u++) {
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             if(edge[i].v == S || edge[i].v == T || (i & )) continue;
             edge[i^].cap++;
         }
     }
 }

 void Dfs(int u) {
     for(int i = head[u]; ~i; i = edge[i].nxt) {
         int v = edge[i].v;
         if(i &  || !edge[i^].cap || v == S || v == T || v == SS || v == ST) continue;
         edge[i^].cap--;
         printf(" %d", v);
         Dfs(v);
         break;
     }
 }

 int main() {
     int n;
     while(~scanf("%d", &n)) {
         memset(head, -, sizeof(head)); tot = ;
         memset(out, , sizeof(out)); memset(in, , sizeof(in));
         S = n + , T = n + , SS = n + , ST = n + ;
         for(int i = ; i <= n; i++) {
             int k; scanf("%d", &k);
             while(k--) {
                 int x; scanf("%d", &x);
                 out[i]++; in[x]++;
                 Add(i, x, INF);
             }
         }
         for(int i = ; i <= n; i++) {
             if(!out[i]) Add(i, T, INF);
             if(!in[i]) Add(S, i, INF);
             int deg = in[i] - out[i];
             if(deg > ) Add(SS, i, deg);
             else if(deg < ) Add(i, ST, -deg);
         }
         Add(T, S, INF);
         ISAP(SS, ST, ST + );
         int ans = edge[tot-].cap;
         Delete();
         ans -= ISAP(T, S, T + );
         printf("%d\n", ans);
         Update(n);
         int cur = head[S];
         for(int k = ; k <= ans; k++) {
             for(int i = cur; ~i; i = edge[i].nxt) {
                 if(!(i & ) && edge[i^].cap) {
                     int v = edge[i].v;
                     edge[i^].cap--;
                     printf("%d", v);
                     Dfs(edge[i].v);
                     puts("");
                     cur = i;
                     break;
                 }
             }
         }
     }
     return ;
 }

写法二：

 #include <bits/stdc++.h>
 using namespace std;
 #define N 210
 #define INF 0x3f3f3f3f
 struct Edge {
     int u, v, nxt, cap;
 } edge[N*N];
 int head[N], tot, dis[N], cur[N], pre[N], gap[N], in[N], out[N], S, T, SS, ST, n;

 void Add(int u, int v, int cap) {
     edge[tot].u = u, edge[tot].v = v, edge[tot].nxt = head[u], edge[tot].cap = cap, head[u] = tot++;
     edge[tot].u = v, edge[tot].v = u, edge[tot].nxt = head[v], edge[tot].cap = , head[v] = tot++;
 }

 int BFS(int T) {
     memset(dis, INF, sizeof(dis));
     memset(gap, , sizeof(gap));
     memcpy(cur, head, sizeof(cur));
     dis[T] = , gap[]++;
     queue<int> que; que.push(T);
     while(!que.empty()) {
         int u = que.front(); que.pop();
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v;
             if(dis[v] == INF) {
                 dis[v] = dis[u] + ;
                 gap[dis[v]]++;
                 que.push(v);
             }
         }
     }
 }

 int ISAP(int S, int T, int n) {
     BFS(T);
     int u = pre[S] = S, i, index, flow, ans = ;
     while(dis[S] < n) {
         if(u == T) {
             flow = INF;
             for(i = S; i != T; i = edge[cur[i]].v)
                 if(flow > edge[cur[i]].cap) flow = edge[cur[i]].cap, index = i;
             for(i = S; i != T; i = edge[cur[i]].v)
                 edge[cur[i]].cap -= flow, edge[cur[i]^].cap += flow;
             ans += flow, u = index;
         }
         for(i = cur[u]; ~i; i = edge[i].nxt) if(edge[i].cap && dis[edge[i].v] +  == dis[u]) break;
         if(~i) {
             cur[u] = i; pre[edge[i].v] = u; u = edge[i].v;
         } else {
             if(--gap[dis[u]] == ) break;
             int md = n;
             for(int i = head[u]; ~i; i = edge[i].nxt)
                 if(edge[i].cap && dis[edge[i].v] < md) md = dis[edge[i].v], cur[u] = i;
             gap[dis[u] = md + ]++;
             u = pre[u];
         }
     }
     return ans;
 }

 void Delete() {
     for(int i = head[SS]; ~i; i = edge[i].nxt) edge[i].cap = edge[i^].cap = ;
     for(int i = head[ST]; ~i; i = edge[i].nxt) edge[i].cap = edge[i^].cap = ;
     edge[tot-].cap = edge[(tot-)^].cap = ;
 }

 void Update(int n) {
     for(int u = ; u <= n; u++) {
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             if(edge[i].v == S || edge[i].v == T || (i & )) continue;
             edge[i^].cap++;
         }
     }
 }

 void Dfs(int u) {
     for(int i = head[u]; ~i; i = edge[i].nxt) {
         int v = edge[i].v;
         if(i &  || !edge[i^].cap || v > n) continue;
         edge[i^].cap--;
         printf(" %d", v);
         Dfs(v); break;
     }
 }

 void Solve() {
     for(int u = ; u <= n; u++) {
         for(int i = head[u]; ~i; i = edge[i].nxt) {
             int v = edge[i].v;
             if(i & ) continue;
             edge[i^].cap++;
         }
     }
     for(int i = head[S]; ~i; i = edge[i].nxt) {
         if(i & ) continue;
         while(edge[i^].cap) {
             edge[i^].cap--;
             int v = edge[i].v;
             printf("%d", v);
             Dfs(v); puts("");
         }
     }
 }

 int main() {
     while(~scanf("%d", &n)) {
         memset(head, -, sizeof(head)); tot = ;
         memset(out, , sizeof(out)); memset(in, , sizeof(in));
         S = n + , T = n + , SS = n + , ST = n + ;
         for(int i = ; i <= n; i++) {
             int k; scanf("%d", &k);
             while(k--) {
                 int x; scanf("%d", &x);
                 out[i]++; in[x]++;
                 Add(i, x, INF);
             }
         }
         for(int i = ; i <= n; i++) {
             if(!out[i]) Add(i, T, INF);
             if(!in[i]) Add(S, i, INF);
             int deg = in[i] - out[i];
             if(deg > ) Add(SS, i, deg);
             else if(deg < ) Add(i, ST, -deg);
         }
         ISAP(SS, ST, ST + );
         Add(T, S, INF);
         int ans = ISAP(SS, ST, ST + );
         printf("%d\n", ans);
         Solve();
     }
     return ;
 }