USACO 4.4 Pollutant Control (milk6)

几个问题不明白：

1. 对每条边乘以一个常数，在加1，经过这样处理后为什么能够求出边数最少的最小割。如果不乘以一个常数，直接加1，这样能否求出题目要求的最小割

2. 如何保证输出编号最小的最小割边集

 

问题1：

       求最小边数的最小割，一种方法是对原始图求最大流，再将每条边容量加1，再求最大流，此时两次最大流的差值便是最小边数最小割的值。用这种方法能够通过此题的所有数据（对前两问）,但我还没能形式化的给出证明，姑且认为它是对的......

标准做法中，对于每条边先乘以一个常数，再进行类似的处理。该种方法可以只求一次最大流就得出解，我想这也许是标准做法的原因所在

 

1. #include <iostream>
3. using namespace std;
5. const int N = 40;
6. const int M = 1010;
8. long long ad[N][N], flow[N][N];
9. int pre[N], q[N], head, tail, n;
10. bool st[N];
11. long long inc[N];
13. struct edgeNode
14. {
15.     int x, y;
16. }edge[M];
18. bool BFS(int src, int des)
19. {
20.     int i, j, k;
21.     head = tail = 1;
22.     
23.     q[1] = src; inc[src] = (long long)(1047483647) * 2147483647;
25.     memset(pre, -1, sizeof(pre));
26.     
27.     while(head <= tail)
28.     {
29.         i = q[head++];
30.         for(j = 1; j <= n; j++)
31.         {
32.             if(pre[j] == -1 && ad[i][j] > flow[i][j])
33.             {
34.                 pre[j] = i;
35.                 inc[j] = min(inc[i], ad[i][j] - flow[i][j]);
36.                 if(j == des) return true;
37.                 q[++tail] = j;
38.             }
39.         }
40.     }
41.     return false;
42. }
43.     
44.     
46. long long Edmonds_Karp(int src, int des)
47. {
48.     long long ans = 0;
49.     while(BFS(src, des))
50.     {
51.         ans += inc[des];
52.         for(int i = des; i != src; i = pre[i])
53.         {
54.             flow[pre[i]][i] += inc[des];
55.             flow[i][pre[i]] -= inc[des];
56.         }
57.     }
58.     return ans;
59. }
61. void DFS(int x)
62. {
63.     st[x] = true;
64.     for(int i = 1; i <= n; i++)
65.     {
66.         if(ad[x][i] > flow[x][i] && !st[i])
67.             DFS(i);
68.     }
69. }
70.     
72. int main()
73. {
74.     int i, j, k, t, m;
75.     
76.     freopen("milk6.in", "r", stdin);
77.     freopen("milk6.out", "w", stdout);
78.     
79.     scanf("%d%d",&n, &m);
80.     for(i = 0; i < m; i++)
81.     {
82.         scanf("%d%d%d",&j, &k, &t);
83.         edge[i] = (edgeNode){j, k};
84.         ad[j][k] += 500000 + i + (long long)500000 * 1001 * t;
85.     }
86.     long long ans = Edmonds_Karp(1, n);
87.     DFS(1);
88.     printf("%Ld %Ld/n", ans / (500000 * 1001) , (ans % (500000 * 1001)) / 500000 );
89.     for(i = 0; i < m; i++)
90.         if(st[edge[i].x] && ! st[edge[i].y]) 
91.             printf("%d/n",i + 1);
93.     scanf("%d",&n);
94.     return 0;
95. }