【线性规划和网络流24题】

（1）飞行员配对方案问题：二分图最大匹配。

思路：略。

View Code 
 1 #include<cstdio>
 2 #include<cstring>
 3 #define MAXN 1010
 4 int cx[MAXN], cy[MAXN];
 5 int first[MAXN], next[MAXN], v[MAXN], e;
 6 bool vis[MAXN];
 7 inline void addEdge(int x, int y) {
 8     v[e] = y;
 9     next[e] = first[x];
10     first[x] = e++;
11 }
12 int path(int x) {
13     int i;
14     int y;
15     for (i = first[x]; i != -1; i = next[i]) {
16         y = v[i];
17         if (!vis[y]) {
18             vis[y] = true;
19             if (cy[y] == -1 || path(cy[y])) {
20                 cx[x] = y;
21                 cy[y] = x;
22                 return 1;
23             }
24         }
25     }
26     return 0;
27 }
28 int main() {
29     int n, m;
30     int i;
31     int x, y;
32     int ans;
33     while (~scanf("%d%d", &m, &n)) {
34         e = 0;
35         memset(first, -1, sizeof(first));
36         while (scanf("%d%d", &x, &y), x != -1) {
37             addEdge(x, y);
38         }
39         ans = 0;
40         memset(cx, -1, sizeof(cx));
41         memset(cy, -1, sizeof(cy));
42         for (i = 1; i <= m; i++) {
43             memset(vis, false, sizeof(vis));
44             ans += path(i);
45         }
46         if (ans) {
47             printf("%d\n", ans);
48             for (i = 1; i <= m; i++) {
49                 if (cx[i] != -1) {
50                     printf("%d %d\n", i, cx[i]);
51                 }
52             }
53         } else {
54             puts("No Solution!");
55         }
56     }
57     return 0;
58 }

 

（2）太空飞行计划问题：最大权闭合图。

思路：

1。源向实验连边，流量为收益。

2。仪器向汇连边，流量为消耗。

3。实验向仪器连边，流量为无穷。

4。所有实验的收益-最大流=最大收益。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<vector>
  4 #include<algorithm>
  5 #include<iostream>
  6 #define MAXL 1010
  7 #define MAXN 100010
  8 #define MAXM 1000010
  9 #define oo 0x7FFFFFFF
 10 using namespace std;
 11 int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
 12 int n;
 13 int src, des;
 14 
 15 bool flag;
 16 bool vis[MAXL];
 17 char str[MAXN];
 18 vector<int> g[MAXL];
 19 vector<int> test;
 20 vector<int> app;
 21 int a[MAXL];
 22 inline void addEdge(int x, int y, int val) {
 23     v[e] = y;
 24     cost[e] = val;
 25     next[e] = first[x];
 26     first[x] = e++;
 27 
 28     v[e] = x;
 29     cost[e] = 0;
 30     next[e] = first[y];
 31     first[y] = e++;
 32 }
 33 int SAP() {
 34     int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
 35     int flow = 0;
 36     int aug = oo;
 37     int x, y;
 38     bool flag;
 39     for (int i = 0; i < n; i++) {
 40         cur[i] = first[i];
 41         gap[i] = dis[i] = 0;
 42     }
 43     gap[src] = n;
 44     x = pre[src] = src;
 45     while (dis[src] < n) {
 46         flag = false;
 47         for (int &j = cur[x]; j != -1; j = next[j]) {
 48             y = v[j];
 49             if (cost[j] > 0 && dis[x] == dis[y] + 1) {
 50                 flag = true;
 51                 aug = min(aug, cost[j]);
 52                 pre[y] = x;
 53                 x = y;
 54                 if (x == des) {
 55                     flow += aug;
 56                     while (x != src) {
 57                         x = pre[x];
 58                         cost[cur[x]] -= aug;
 59                         cost[cur[x] ^ 1] += aug;
 60                     }
 61                     aug = oo;
 62                 }
 63                 break;
 64             }
 65         }
 66         if (flag) {
 67             continue;
 68         }
 69         int tmp = n;
 70         for (int j = first[x]; j != -1; j = next[j]) {
 71             y = v[j];
 72             if (cost[j] > 0 && dis[y] < tmp) {
 73                 tmp = dis[y];
 74                 cur[x] = j;
 75             }
 76         }
 77         if ((--gap[dis[x]]) == 0) {
 78             break;
 79         }
 80         gap[dis[x] = tmp + 1]++;
 81         x = pre[x];
 82     }
 83     return flow;
 84 }
 85 void out(vector<int> res) {
 86     int i;
 87     sort(res.begin(), res.end());
 88     res.resize(unique(res.begin(), res.end()) - res.begin());
 89     for (i = 0; i < (int) res.size(); i++) {
 90         if (i) {
 91             putchar(' ');
 92         }
 93         printf("%d", res[i]);
 94     }
 95     putchar('\n');
 96 }
 97 void dfs(int x) {
 98     int i;
 99     vis[x] = true;
100     if (x == des) {
101         flag = false;
102     }
103     for (i = first[x]; i != -1; i = next[i]) {
104         if (!vis[v[i]] && cost[i] > 0) {
105             dfs(v[i]);
106         }
107     }
108 }
109 int main() {
110     int m;
111     int i, j, k;
112     int len;
113     int ans;
114     while (~scanf("%d%d", &m, &n)) {
115         src = 0;
116         des = n + m + 1;
117         e = 0;
118         memset(first, -1, sizeof(first));
119         gets(str);
120         for (i = 1; i <= m; i++) {
121             g[i].clear();
122             gets(str);
123             len = strlen(str);
124             for (j = 0; j < len; j++) {
125                 for (; j < len && str[j] == ' '; j++)
126                     ;
127                 if (j < len) {
128                     sscanf(str + j, "%d", &k);
129                     g[i].push_back(k);
130                 }
131                 for (; j < len && isdigit(str[j]); j++)
132                     ;
133             }
134         }
135         for (i = 1; i <= n; i++) {
136             scanf("%d", &a[i]);
137             addEdge(m + i, des, a[i]);
138         }
139         ans = 0;
140         for (i = 1; i <= m; i++) {
141             addEdge(src, i, g[i][0]);
142             ans += g[i][0];
143             for (j = 1; j < (int) g[i].size(); j++) {
144                 addEdge(i, m + g[i][j], oo);
145             }
146         }
147         n = des + 1;
148         ans -= SAP();
149         test.clear();
150         app.clear();
151         for (i = first[src]; i != -1; i = next[i]) {
152             k = v[i];
153             flag = true;
154             memset(vis, false, sizeof(vis));
155             dfs(k);
156             if (flag) {
157                 test.push_back(k);
158                 for (j = 1; j < (int) g[k].size(); j++) {
159                     app.push_back(g[k][j]);
160                 }
161             }
162         }
163         out(test);
164         out(app);
165         printf("%d\n", ans);
166     }
167     return 0;
168 }

 

 （3）最小路径覆盖问题：有向无环图最小路径覆盖。

思路：

1。当原图没有边，增加一条边，就增加一个匹配，显然少了一条路径。

2。当已经有了一个匹配，增加一条边，不会增加匹配数，路径数需增加1。

View Code 
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<vector>
 4 #define MAXN 1010
 5 #define MAXM 100010
 6 using namespace std;
 7 int first[MAXN], v[MAXM], next[MAXM], e;
 8 int cx[MAXN], cy[MAXN];
 9 bool vis[MAXN];
10 vector<int> res;
11 inline void addEdge(int x, int y) {
12     next[e] = first[x];
13     v[e] = y;
14     first[x] = e++;
15 }
16 int path(int x) {
17     int i;
18     int y;
19     for (i = first[x]; i != -1; i = next[i]) {
20         y = v[i];
21         if (!vis[y]) {
22             vis[y] = true;
23             if (cy[y] == -1 || path(cy[y])) {
24                 cx[x] = y;
25                 cy[y] = x;
26                 return 1;
27             }
28         }
29     }
30     return 0;
31 }
32 int Match(int n) {
33     int i;
34     int ans = 0;
35     memset(cx, -1, sizeof(cx));
36     memset(cy, -1, sizeof(cy));
37     for (i = 1; i <= n; i++) {
38         memset(vis, false, sizeof(vis));
39         ans += path(i);
40     }
41     return n - ans;
42 }
43 void dfs(int x) {
44     vis[x] = true;
45     res.push_back(x);
46     if (cx[x] != -1) {
47         dfs(cx[x]);
48     }
49 }
50 int main() {
51     int n, m;
52     int i, j;
53     int x, y;
54     int ans;
55     while (~scanf("%d%d", &n, &m)) {
56         e = 0;
57         memset(first, -1, sizeof(first));
58         for (i = 0; i < m; i++) {
59             scanf("%d%d", &x, &y);
60             addEdge(x, y);
61         }
62         ans = Match(n);
63         memset(vis, false, sizeof(vis));
64         for (i = 1; i <= n; i++) {
65             if (!vis[i]) {
66                 res.clear();
67                 dfs(i);
68                 for (j = 0; j < (int) res.size() - 1; j++) {
69                     printf("%d ", res[j]);
70                 }
71                 printf("%d\n", res[j]);
72             }
73         }
74         printf("%d\n", ans);
75     }
76     return 0;
77 }

 

（4）魔术球问题：有向无环图最小路径覆盖。

思路：

1。若x+y为平方数，则x,y'连一条有向边。

2。递增答案，同时增加新的边，更新二分图的交错路。

3。最小路径覆盖=顶点数-二分图最大匹配。

View Code 
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<vector>
 4 #define MAXN 2010
 5 #define MAXM 200010
 6 using namespace std;
 7 int first[MAXN], next[MAXM], v[MAXM], e;
 8 int cx[MAXN], cy[MAXN];
 9 int nx[MAXN];
10 bool vis[MAXN];
11 bool sqr[MAXM];
12 vector<int> res;
13 void init() {
14     int i;
15     memset(sqr, false, sizeof(sqr));
16     for (i = 1; i * i < MAXM; i++) {
17         sqr[i * i] = true;
18     }
19 }
20 inline void addEdge(int x, int y) {
21     v[e] = y;
22     next[e] = first[x];
23     first[x] = e++;
24 }
25 int path(int x) {
26     int i;
27     int y;
28     for (i = first[x]; i != -1; i = next[i]) {
29         y = v[i];
30         if (!vis[y]) {
31             vis[y] = true;
32             if (cy[y] == -1 || path(cy[y])) {
33                 cx[x] = y;
34                 cy[y] = x;
35                 return 1;
36             }
37         }
38     }
39     return 0;
40 }
41 int cal(int n) {
42     int i;
43     int ans;
44     for (i = 1; i < n; i++) {
45         if (sqr[i + n]) {
46             addEdge(i, n);
47         }
48     }
49     ans = 0;
50     for (i = 1; i <= n; i++) {
51         if (cx[i] == -1) {
52             memset(vis, false, sizeof(vis));
53             ans += path(i);
54         } else {
55             ans++;
56         }
57     }
58     return n - ans;
59 }
60 void dfs(int x) {
61     vis[x] = true;
62     res.push_back(x);
63     if (nx[x] != -1) {
64         dfs(nx[x]);
65     }
66 }
67 int main() {
68     int n;
69     int i, j;
70     init();
71     while (~scanf("%d", &n)) {
72         e = 0;
73         memset(first, -1, sizeof(first));
74         memset(cx, -1, sizeof(cx));
75         memset(cy, -1, sizeof(cy));
76         for (i = 1; cal(i) <= n; i++) {
77             memcpy(nx, cx, sizeof(nx));
78         }
79         n = i - 1;
80         printf("%d\n", n);
81         memset(vis, false, sizeof(vis));
82         for (i = 1; i <= n; i++) {
83             if (!vis[i]) {
84                 res.clear();
85                 dfs(i);
86                 for (j = 0; j < (int) res.size() - 1; j++) {
87                     printf("%d ", res[j]);
88                 }
89                 printf("%d\n", res[j]);
90             }
91         }
92     }
93     return 0;
94 }

 

（5）圆桌问题：二分图多重匹配。

思路：

1。从源点向每个单位连边，流量为单位人数。

2。从每个圆桌向汇点连边，流量为圆桌人数。

3。每个单位向每个圆桌都连边，流量为1。

4。求最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<vector>
  4 #define MAXN 1010
  5 #define MAXM 1000010
  6 #define oo 0x7FFFFFFF
  7 using namespace std;
  8 int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
  9 int n;
 10 int src, des;
 11 inline void addEdge(int x, int y, int val) {
 12     v[e] = y;
 13     cost[e] = val;
 14     next[e] = first[x];
 15     first[x] = e++;
 16 
 17     v[e] = x;
 18     cost[e] = 0;
 19     next[e] = first[y];
 20     first[y] = e++;
 21 }
 22 int SAP() {
 23     int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
 24     int flow = 0;
 25     int aug = oo;
 26     int x, y;
 27     bool flag;
 28     for (int i = 0; i < n; i++) {
 29         cur[i] = first[i];
 30         gap[i] = dis[i] = 0;
 31     }
 32     gap[src] = n;
 33     x = pre[src] = src;
 34     while (dis[src] < n) {
 35         flag = false;
 36         for (int &j = cur[x]; j != -1; j = next[j]) {
 37             y = v[j];
 38             if (cost[j] > 0 && dis[x] == dis[y] + 1) {
 39                 flag = true;
 40                 aug = min(aug, cost[j]);
 41                 pre[y] = x;
 42                 x = y;
 43                 if (x == des) {
 44                     flow += aug;
 45                     while (x != src) {
 46                         x = pre[x];
 47                         cost[cur[x]] -= aug;
 48                         cost[cur[x] ^ 1] += aug;
 49                     }
 50                     aug = oo;
 51                 }
 52                 break;
 53             }
 54         }
 55         if (flag) {
 56             continue;
 57         }
 58         int tmp = n;
 59         for (int j = first[x]; j != -1; j = next[j]) {
 60             y = v[j];
 61             if (cost[j] > 0 && dis[y] < tmp) {
 62                 tmp = dis[y];
 63                 cur[x] = j;
 64             }
 65         }
 66         if ((--gap[dis[x]]) == 0) {
 67             break;
 68         }
 69         gap[dis[x] = tmp + 1]++;
 70         x = pre[x];
 71     }
 72     return flow;
 73 }
 74 int main() {
 75     int m;
 76     int i, j;
 77     int tot;
 78     vector<int> res[MAXN];
 79     scanf("%d%d", &m, &n);
 80     src = 0;
 81     des = n + m + 1;
 82     e = 0;
 83     memset(first, -1, sizeof(first));
 84     tot = 0;
 85     for (i = 1; i <= m; i++) {
 86         scanf("%d", &j);
 87         addEdge(src, i, j);
 88         tot += j;
 89     }
 90     for (i = 1; i <= n; i++) {
 91         scanf("%d", &j);
 92         addEdge(m + i, des, j);
 93     }
 94     for (i = 1; i <= m; i++) {
 95         for (j = m + 1; j <= n + m; j++) {
 96             addEdge(i, j, 1);
 97         }
 98     }
 99     n = des + 1;
100     for (i = 0; i < MAXN; i++) {
101         res[i].clear();
102     }
103     if (tot == SAP()) {
104         puts("1");
105         for (i = first[src]; i != -1; i = next[i]) {
106             for (j = first[v[i]]; j != -1; j = next[j]) {
107                 if (cost[j] == 0) {
108                     res[v[i]].push_back(v[j] - m);
109                 }
110             }
111         }
112         for (i = 1; i <= m; i++) {
113             for (j = 0; j < (int) res[i].size() - 1; j++) {
114                 printf("%d ", res[i][j]);
115             }
116             printf("%d\n", res[i][j]);
117         }
118     } else {
119         puts("0");
120     }
121     return 0;
122 }

 

（6）最长递增子序列问题：最多不相交路径。

思路：

1。对于第一问：dp即可。

2。每个点取的次数有要求，所以需要拆点，限制流量。

3。控制最长递增子序列，要从dp转移来连边。

 题目描述有错：应是最长非降子序列，而不是严格递增的。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<vector>
  4 #define MAXN 10010
  5 #define MAXM 1000010
  6 #define oo 123456789
  7 using namespace std;
  8 int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
  9 int n;
 10 int src, des;
 11 
 12 int dp[MAXN];
 13 int arr[MAXN];
 14 inline void addEdge(int x, int y, int val) {
 15     v[e] = y;
 16     cost[e] = val;
 17     next[e] = first[x];
 18     first[x] = e++;
 19 
 20     v[e] = x;
 21     cost[e] = 0;
 22     next[e] = first[y];
 23     first[y] = e++;
 24 }
 25 int SAP() {
 26     int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
 27     int flow = 0;
 28     int aug = oo;
 29     int x, y;
 30     bool flag;
 31     for (int i = 0; i < n; i++) {
 32         cur[i] = first[i];
 33         gap[i] = dis[i] = 0;
 34     }
 35     gap[src] = n;
 36     x = pre[src] = src;
 37     while (dis[src] < n) {
 38         flag = false;
 39         for (int &j = cur[x]; j != -1; j = next[j]) {
 40             y = v[j];
 41             if (cost[j] > 0 && dis[x] == dis[y] + 1) {
 42                 flag = true;
 43                 aug = min(aug, cost[j]);
 44                 pre[y] = x;
 45                 x = y;
 46                 if (x == des) {
 47                     flow = min(flow + aug, oo);
 48                     while (x != src) {
 49                         x = pre[x];
 50                         cost[cur[x]] -= aug;
 51                         cost[cur[x] ^ 1] += aug;
 52                     }
 53                     aug = oo;
 54                 }
 55                 break;
 56             }
 57         }
 58         if (flag) {
 59             continue;
 60         }
 61         int tmp = n;
 62         for (int j = first[x]; j != -1; j = next[j]) {
 63             y = v[j];
 64             if (cost[j] > 0 && dis[y] < tmp) {
 65                 tmp = dis[y];
 66                 cur[x] = j;
 67             }
 68         }
 69         if ((--gap[dis[x]]) == 0) {
 70             break;
 71         }
 72         gap[dis[x] = tmp + 1]++;
 73         x = pre[x];
 74     }
 75     return flow;
 76 }
 77 int getIndex(int x) {
 78     return 2 * x - 1;
 79 }
 80 void cal(int len, int val) {
 81     int i, j;
 82     int tmp;
 83     int ans;
 84     e = 0;
 85     memset(first, -1, sizeof(first));
 86     src = 0;
 87     des = 2 * n + 1;
 88     for (i = 1; i <= n; i++) {
 89         if (i == 1 || i == n) {
 90             addEdge(getIndex(i), getIndex(i) + 1, val);
 91         } else {
 92             addEdge(getIndex(i), getIndex(i) + 1, 1);
 93         }
 94     }
 95     for (i = 1; i <= n; i++) {
 96         if (dp[i] == 1) {
 97             addEdge(src, getIndex(i), oo);
 98         }
 99         if (dp[i] == len) {
100             addEdge(getIndex(i) + 1, des, oo);
101         }
102     }
103     for (i = 1; i <= n; i++) {
104         for (j = 1; j < i; j++) {
105             if (arr[i] >= arr[j] && dp[i] == dp[j] + 1) {
106                 addEdge(getIndex(j) + 1, getIndex(i), 1);
107             }
108         }
109     }
110     tmp = n;
111     n = des + 1;
112     ans = SAP();
113     n = tmp;
114     if (ans == oo) {
115         ans = n;
116     }
117     printf("%d\n", ans);
118 }
119 int main() {
120     int i, j;
121     int ans;
122     while (~scanf("%d", &n)) {
123         for (i = 1; i <= n; i++) {
124             scanf("%d", &arr[i]);
125             dp[i] = 1;
126         }
127         for (i = 1; i <= n; i++) {
128             for (j = 1; j < i; j++) {
129                 if (arr[i] >= arr[j]) {
130                     dp[i] = max(dp[i], dp[j] + 1);
131                 }
132             }
133         }
134         ans = 0;
135         for (i = 1; i <= n; i++) {
136             ans = max(ans, dp[i]);
137         }
138         printf("%d\n", ans);
139         cal(ans, 1);
140         cal(ans, oo);
141     }
142     return 0;
143 }

 

（7）试题库问题：二分图多重匹配。

思路：

1。从源点向每道试题连边，流量为1。

2。从每个类型向汇点连边，流量为每个类型所需要的题数。

3。每个试题向所属的类型都连边，流量为1。

4。求最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<vector>
  4 #define MAXN 1010
  5 #define MAXM 1000010
  6 #define oo 0x7FFFFFFF
  7 using namespace std;
  8 int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
  9 int n;
 10 int src, des;
 11 inline void addEdge(int x, int y, int val) {
 12     v[e] = y;
 13     cost[e] = val;
 14     next[e] = first[x];
 15     first[x] = e++;
 16 
 17     v[e] = x;
 18     cost[e] = 0;
 19     next[e] = first[y];
 20     first[y] = e++;
 21 }
 22 int SAP() {
 23     int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
 24     int flow = 0;
 25     int aug = oo;
 26     int x, y;
 27     bool flag;
 28     for (int i = 0; i < n; i++) {
 29         cur[i] = first[i];
 30         gap[i] = dis[i] = 0;
 31     }
 32     gap[src] = n;
 33     x = pre[src] = src;
 34     while (dis[src] < n) {
 35         flag = false;
 36         for (int &j = cur[x]; j != -1; j = next[j]) {
 37             y = v[j];
 38             if (cost[j] > 0 && dis[x] == dis[y] + 1) {
 39                 flag = true;
 40                 aug = min(aug, cost[j]);
 41                 pre[y] = x;
 42                 x = y;
 43                 if (x == des) {
 44                     flow += aug;
 45                     while (x != src) {
 46                         x = pre[x];
 47                         cost[cur[x]] -= aug;
 48                         cost[cur[x] ^ 1] += aug;
 49                     }
 50                     aug = oo;
 51                 }
 52                 break;
 53             }
 54         }
 55         if (flag) {
 56             continue;
 57         }
 58         int tmp = n;
 59         for (int j = first[x]; j != -1; j = next[j]) {
 60             y = v[j];
 61             if (cost[j] > 0 && dis[y] < tmp) {
 62                 tmp = dis[y];
 63                 cur[x] = j;
 64             }
 65         }
 66         if ((--gap[dis[x]]) == 0) {
 67             break;
 68         }
 69         gap[dis[x] = tmp + 1]++;
 70         x = pre[x];
 71     }
 72     return flow;
 73 }
 74 int main() {
 75     int m;
 76     int i, j, k;
 77     int tot;
 78     vector<int> res[MAXN];
 79     while (~scanf("%d%d", &m, &n)) {
 80         tot = 0;
 81         src = 0;
 82         des = m + n + 1;
 83         e = 0;
 84         memset(first, -1, sizeof(first));
 85         for (i = 1; i <= m; i++) {
 86             scanf("%d", &j);
 87             addEdge(n + i, des, j);
 88             tot += j;
 89         }
 90         for (i = 1; i <= n; i++) {
 91             scanf("%d", &j);
 92             addEdge(src, i, 1);
 93             while (j--) {
 94                 scanf("%d", &k);
 95                 addEdge(i, n + k, 1);
 96             }
 97         }
 98         k = n;
 99         n = des + 1;
100         if (SAP() == tot) {
101             for (i = 0; i < MAXN; i++) {
102                 res[i].clear();
103             }
104             for (i = first[src]; i != -1; i = next[i]) {
105                 for (j = first[v[i]]; j != -1; j = next[j]) {
106                     if (cost[j] == 0) {
107                         if (v[j] > k)
108                             res[v[j] - k].push_back(v[i]);
109                     }
110                 }
111             }
112             for (i = 1; i <= m; i++) {
113                 printf("%d:", i);
114                 for (j = 0; j < (int) res[i].size(); j++) {
115                     printf(" %d", res[i][j]);
116                 }
117                 putchar('\n');
118             }
119         } else {
120             puts("No Solution!");
121         }
122     }
123     return 0;
124 }

 

（9）方格取数问题：二分图点权最大独立集。

思路：

1。方格黑白染色。源向黑格连边，流量为点权；白格向汇连边，流量为点权；黑格与相邻的白格连边，流量为oo。因此，最小割是简单割，即最小权覆盖集。

2。由于独立集与覆盖集是互补的，所以最小权覆盖集+最大权独立集=总权值。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<vector>
  4 #define MAXL 210
  5 #define MAXN 100010
  6 #define MAXM 1000010
  7 #define oo 123456789
  8 using namespace std;
  9 int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
 10 int n, m;
 11 int src, des;
 12 int arr[MAXL][MAXL];
 13 int go[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
 14 inline void addEdge(int x, int y, int val) {
 15     v[e] = y;
 16     cost[e] = val;
 17     next[e] = first[x];
 18     first[x] = e++;
 19 
 20     v[e] = x;
 21     cost[e] = 0;
 22     next[e] = first[y];
 23     first[y] = e++;
 24 }
 25 int SAP() {
 26     int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
 27     int flow = 0;
 28     int aug = oo;
 29     int x, y;
 30     bool flag;
 31     for (int i = 0; i < n; i++) {
 32         cur[i] = first[i];
 33         gap[i] = dis[i] = 0;
 34     }
 35     gap[src] = n;
 36     x = pre[src] = src;
 37     while (dis[src] < n) {
 38         flag = false;
 39         for (int &j = cur[x]; j != -1; j = next[j]) {
 40             y = v[j];
 41             if (cost[j] > 0 && dis[x] == dis[y] + 1) {
 42                 flag = true;
 43                 aug = min(aug, cost[j]);
 44                 pre[y] = x;
 45                 x = y;
 46                 if (x == des) {
 47                     flow += aug;
 48                     while (x != src) {
 49                         x = pre[x];
 50                         cost[cur[x]] -= aug;
 51                         cost[cur[x] ^ 1] += aug;
 52                     }
 53                     aug = oo;
 54                 }
 55                 break;
 56             }
 57         }
 58         if (flag) {
 59             continue;
 60         }
 61         int tmp = n;
 62         for (int j = first[x]; j != -1; j = next[j]) {
 63             y = v[j];
 64             if (cost[j] > 0 && dis[y] < tmp) {
 65                 tmp = dis[y];
 66                 cur[x] = j;
 67             }
 68         }
 69         if ((--gap[dis[x]]) == 0) {
 70             break;
 71         }
 72         gap[dis[x] = tmp + 1]++;
 73         x = pre[x];
 74     }
 75     return flow;
 76 }
 77 int getIndex(int x, int y) {
 78     return (x - 1) * m + y;
 79 }
 80 int main() {
 81     int i, j, k;
 82     int x, y;
 83     int ans;
 84     while (~scanf("%d%d", &n, &m)) {
 85         src = 0;
 86         des = m * n + 1;
 87         e = 0;
 88         memset(first, -1, sizeof(first));
 89         ans = 0;
 90         for (i = 1; i <= n; i++) {
 91             for (j = 1; j <= m; j++) {
 92                 scanf("%d", &arr[i][j]);
 93                 ans += arr[i][j];
 94                 if ((i + j) & 1) {
 95                     addEdge(src, getIndex(i, j), arr[i][j]);
 96                     for (k = 0; k < 4; k++) {
 97                         x = i + go[k][0];
 98                         y = j + go[k][1];
 99                         if (x > 0 && x <= n && y > 0 && y <= m) {
100                             addEdge(getIndex(i, j), getIndex(x, y), oo);
101                         }
102                     }
103                 } else {
104                     addEdge(getIndex(i, j), des, arr[i][j]);
105                 }
106             }
107         }
108         n = des + 1;
109         ans = ans - SAP();
110         printf("%d\n", ans);
111     }
112     return 0;
113 }

 

（10）餐巾计划问题：线性规划网络优化。

思路：

1。由于第i天的新餐巾可以由i-m天的脏餐巾洗来，因此考虑按天数建模。

2。每天的餐巾有新旧之分，则考虑拆点，每天的新餐巾数量和每天的旧餐巾数量。

3。新餐巾可以直接买来。

4。新餐巾可以由前些天的旧餐巾洗来。

5。旧餐巾可以由上一天的旧餐巾积累而来。

6。求最小费用最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<algorithm>
  5 #define oo 123456
  6 #define MAXN 100010
  7 #define MAXM 1000010
  8 using namespace std;
  9 int V, e;
 10 int src, des;
 11 int lk[MAXN], father[MAXN];
 12 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 13 int dis[MAXN];
 14 bool inq[MAXN];
 15 
 16 int arr[MAXN];
 17 void addEdge(int x, int y, int f, int c) {
 18     v[e] = y;
 19     flow[e] = f;
 20     cost[e] = c;
 21     next[e] = first[x];
 22     first[x] = e++;
 23 
 24     v[e] = x;
 25     flow[e] = 0;
 26     cost[e] = -c;
 27     next[e] = first[y];
 28     first[y] = e++;
 29 }
 30 bool SPFA() {
 31     int i, u;
 32     deque<int> q;
 33     memset(inq, false, sizeof(inq));
 34     for (i = 0; i <= V; i++) {
 35         dis[i] = oo;
 36     }
 37     dis[src] = 0;
 38     q.push_back(src);
 39     inq[src] = true;
 40     while (!q.empty()) {
 41         u = q.front();
 42         q.pop_front();
 43         inq[u] = false;
 44         for (i = first[u]; i != -1; i = next[i]) {
 45             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 46                 dis[v[i]] = dis[u] + cost[i];
 47                 father[v[i]] = u;
 48                 lk[v[i]] = i;
 49                 if (!inq[v[i]]) {
 50                     inq[v[i]] = true;
 51                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 52                         q.push_front(v[i]);
 53                     } else {
 54                         q.push_back(v[i]);
 55                     }
 56                 }
 57             }
 58         }
 59     }
 60     return dis[des] != oo;
 61 }
 62 int MinCostMaxFlow() {
 63     int u;
 64     int ans;
 65     int tmp;
 66     for (ans = 0; SPFA();) {
 67         tmp = oo;
 68         for (u = des; u; u = father[u]) {
 69             tmp = min(tmp, flow[lk[u]]);
 70         }
 71         for (u = des; u; u = father[u]) {
 72             flow[lk[u]] -= tmp;
 73             flow[lk[u] ^ 1] += tmp;
 74         }
 75         ans += tmp * dis[des];
 76     }
 77     return ans;
 78 }
 79 int main() {
 80     int i;
 81     int n;
 82     int buy, fastCost, slowCost, slowDay, fastDay;
 83     while (~scanf("%d%d%d%d%d%d", &n, &buy, &fastDay, &fastCost, &slowDay,
 84             &slowCost)) {
 85         e = 0;
 86         src = 0;
 87         des = n + n + 1;
 88         V = des;
 89         memset(first, -1, sizeof(first));
 90         for (i = 1; i <= n; i++) {
 91             scanf("%d", &arr[i]);
 92             addEdge(2 * i, des, arr[i], 0);
 93             addEdge(src, 2 * i, arr[i], buy);
 94             addEdge(src, 2 * i - 1, arr[i], 0);
 95         }
 96         for (i = 2; i <= n; i++) {
 97             addEdge(2 * (i - 1) - 1, 2 * i - 1, oo, 0);
 98         }
 99         for (i = 1; i <= n; i++) {
100             if (i + fastDay <= n) {
101                 addEdge(2 * i - 1, 2 * (i + fastDay), oo, fastCost);
102             }
103             if (i + slowDay <= n) {
104                 addEdge(2 * i - 1, 2 * (i + slowDay), oo, slowCost);
105             }
106         }
107         for (i = 1; i <= n; i++) {
108             addEdge(src, i, oo, buy);
109         }
110         printf("%d\n", MinCostMaxFlow());
111     }
112     return 0;
113 }

 

（11）航空路线问题：最长不相交路径。

思路：

1。从东->西，再从西->东。相当于从东->西两条不相交的路径。

2。要求路径最长，则考虑最大费用最大流。

View Code 
  1 #include<iostream>
  2 #include<algorithm>
  3 #include<string>
  4 #include<cstring>
  5 #include<queue>
  6 #include<vector>
  7 #include<map>
  8 #define oo 0x7FFFFFFF
  9 #define MAXL 110
 10 #define MAXN 10010
 11 #define MAXM 1000010
 12 using namespace std;
 13 int V, n, m, e;
 14 int src, des;
 15 int lk[MAXN], father[MAXN];
 16 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 17 int dis[MAXN];
 18 bool inq[MAXN];
 19 
 20 vector<string> city;
 21 map<string, int> mymap;
 22 vector<int> res;
 23 bool g[MAXL][MAXL];
 24 bool vis[MAXN];
 25 void addEdge(int x, int y, int f, int c) {
 26     v[e] = y;
 27     flow[e] = f;
 28     cost[e] = c;
 29     next[e] = first[x];
 30     first[x] = e++;
 31 
 32     v[e] = x;
 33     flow[e] = 0;
 34     cost[e] = -c;
 35     next[e] = first[y];
 36     first[y] = e++;
 37 }
 38 bool SPFA() {
 39     int i, u;
 40     deque<int> q;
 41     memset(inq, false, sizeof(inq));
 42     for (i = 0; i <= V; i++) {
 43         dis[i] = oo;
 44     }
 45     dis[src] = 0;
 46     q.push_back(src);
 47     inq[src] = true;
 48     while (!q.empty()) {
 49         u = q.front();
 50         q.pop_front();
 51         inq[u] = false;
 52         for (i = first[u]; i != -1; i = next[i]) {
 53             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 54                 dis[v[i]] = dis[u] + cost[i];
 55                 father[v[i]] = u;
 56                 lk[v[i]] = i;
 57                 if (!inq[v[i]]) {
 58                     inq[v[i]] = true;
 59                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 60                         q.push_front(v[i]);
 61                     } else {
 62                         q.push_back(v[i]);
 63                     }
 64                 }
 65             }
 66         }
 67     }
 68     return dis[des] != oo;
 69 }
 70 int MinCostMaxFlow(int tot) {
 71     int u;
 72     int ans;
 73     int tmp;
 74     int flux;
 75     for (ans = flux = 0; SPFA();) {
 76         tmp = oo;
 77         for (u = des; u; u = father[u]) {
 78             tmp = min(tmp, flow[lk[u]]);
 79         }
 80         for (u = des; u; u = father[u]) {
 81             flow[lk[u]] -= tmp;
 82             flow[lk[u] ^ 1] += tmp;
 83         }
 84         ans += tmp * dis[des];
 85         flux += tmp;
 86     }
 87     if (flux != tot) {
 88         return oo;
 89     } else {
 90         return ans;
 91     }
 92 }
 93 void dfs(int x) {
 94     vis[x] = true;
 95     int i;
 96     res.push_back(x >> 1);
 97     for (i = first[x]; i != -1; i = next[i]) {
 98         if ((i & 1) == 0 && flow[i] == 0 && !vis[v[i]]) {
 99             dfs(v[i]);
100         }
101     }
102 }
103 int main() {
104     int i, j;
105     string str1, str2;
106     int ans;
107     bool flag;
108     while (cin >> n >> m) {
109         memset(g, false, sizeof(g));
110         src = 0;
111         des = n + n - 1;
112         V = des;
113         e = 0;
114         memset(first, -1, sizeof(first));
115         city.clear();
116         mymap.clear();
117         addEdge(0, 1, 2, 0);
118         addEdge(des - 1, des, 2, 0);
119         for (i = 2; i < des - 1; i += 2) {
120             addEdge(i, i + 1, 1, 0);
121         }
122         for (i = 0; i < n; i++) {
123             cin >> str1;
124             city.push_back(str1);
125             mymap[str1] = i << 1;
126         }
127         while (m--) {
128             cin >> str1 >> str2;
129             i = mymap[str1];
130             j = mymap[str2];
131             if (i > j) {
132                 swap(i, j);
133             }
134             addEdge(i ^ 1, j, 1, -1);
135             g[i / 2][j / 2] = g[j / 2][i / 2] = true;
136         }
137         ans = MinCostMaxFlow(2);
138         if (ans == oo) {
139             if (g[0][n - 1]) {
140                 cout << 2 << endl;
141                 cout << city[0] << endl;
142                 cout << city[n - 1] << endl;
143                 cout << city[0] << endl;
144             } else {
145                 cout << "No Solution!" << endl;
146             }
147         } else {
148             cout << -ans << endl;
149             memset(vis, false, sizeof(vis));
150             flag = false;
151             cout << city[0] << endl;
152             for (i = first[1]; i != -1; i = next[i]) {
153                 if ((i & 1) == 0 && flow[i] == 0 && !vis[v[i]]) {
154                     res.clear();
155                     dfs(v[i]);
156                     if (flag) {
157                         reverse(res.begin(), res.end());
158                     } else {
159                         flag = true;
160                     }
161                     res.resize(unique(res.begin(), res.end()) - res.begin());
162                     for (j = 0; j < (int) res.size(); j++) {
163                         cout << city[res[j]] << endl;
164                     }
165                 }
166             }
167             cout << city[0] << endl;
168         }
169     }
170     return 0;
171 }

 

（12）软件补丁问题：最小转移代价。

思路：

1。只有20个补丁，很容易想到状态压缩。

2。最多(1<<20)个状态，一个状态到另一个状态间有一个花费。

3。求最短花费，就是最短路了。

题目描述有错：第二个字符串中'-'是f1的，'+'是f2的。

View Code 
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<queue>
 4 #define oo 0x7FFFFFFF
 5 #define MAXN 1<<20
 6 #define MAXM 110
 7 using namespace std;
 8 int dis[MAXN];
 9 bool inq[MAXN];
10 struct patch {
11     int b1, b2;
12     int f1, f2;
13     int cost;
14 } p[MAXM];
15 int n, m;
16 void update(char str[], int &x, int &y) {
17     int i;
18     x = y = 0;
19     for (i = 0; str[i]; i++) {
20         if (str[i] == '+') {
21             x |= 1 << i;
22         } else if (str[i] == '-') {
23             y |= 1 << i;
24         }
25     }
26 }
27 void spfa(int src) {
28     int i;
29     int x, y;
30     deque<int> q;
31     memset(inq, false, sizeof(inq));
32     for (i = 0; i < (1 << n); i++) {
33         dis[i] = oo;
34     }
35     dis[src] = 0;
36     q.push_back(src);
37     while (!q.empty()) {
38         x = q.front();
39         q.pop_front();
40         inq[x] = false;
41         for (i = 0; i < m; i++) {
42             if ((x | p[i].b1) == x && (x & p[i].b2) == 0) {
43                 y = x & (~p[i].f1);
44                 y |= p[i].f2;
45                 if (dis[y] > dis[x] + p[i].cost) {
46                     dis[y] = dis[x] + p[i].cost;
47                     if (!inq[y]) {
48                         if (!q.empty() && dis[y] <= dis[q.front()]) {
49                             q.push_front(y);
50                         } else {
51                             q.push_back(y);
52                         }
53                         inq[y] = true;
54                     }
55                 }
56             }
57         }
58     }
59 }
60 int main() {
61     int i;
62     char a[MAXM], b[MAXM];
63     while (~scanf("%d%d", &n, &m)) {
64         for (i = 0; i < m; i++) {
65             scanf("%d %s %s", &p[i].cost, a, b);
66             update(a, p[i].b1, p[i].b2);
67             update(b, p[i].f2, p[i].f1);
68         }
69         spfa((1 << n) - 1);
70         if (dis[0] == oo) {
71             puts("0");
72         } else {
73             printf("%d\n", dis[0]);
74         }
75     }
76     return 0;
77 }

 

（13）星际转移问题：网络判定。

思路：

1。枚举天数。随着天数的增加，不断增加点和边。

2。判最大流是否大于等于K。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<vector>
  5 #define oo 123456
  6 #define MAXN 1010
  7 #define MAXM 100010
  8 using namespace std;
  9 int src;
 10 int des;
 11 int V;
 12 int ans;
 13 vector<int> path[MAXN];
 14 vector<int> cap;
 15 vector<int> ind[MAXN];
 16 vector<int> pos[MAXN];
 17 int G[MAXN][MAXN];
 18 int first[MAXN], next[MAXN], v[MAXN], e;
 19 bool vis[MAXN];
 20 int BFS() {
 21     queue<int> q;
 22     int tmp, i, u, v, head, p[MAXN];
 23     memset(p, -1, sizeof(p));
 24     p[src] = src;
 25     q.push(src);
 26     while (!q.empty()) {
 27         head = q.front();
 28         q.pop();
 29         for (i = 1; i <= V; i++) {
 30             if (G[head][i] > 0 && p[i] == -1) {
 31                 p[i] = head;
 32                 q.push(i);
 33             }
 34         }
 35     }
 36     if (p[des] == -1)
 37         return 0;
 38     for (tmp = oo, u = des; p[u] != u;) {
 39         v = u;
 40         u = p[u];
 41         tmp = min(tmp, G[u][v]);
 42     }
 43     for (u = des; p[u] != u;) {
 44         v = u;
 45         u = p[u];
 46         G[u][v] -= tmp;
 47         G[v][u] += tmp;
 48     }
 49     return tmp;
 50 }
 51 void EdmondsKarp() {
 52     int tmp;
 53     for (; (tmp = BFS()); ans += tmp)
 54         ;
 55 }
 56 inline void addEdge(int x, int y) {
 57     next[e] = first[x];
 58     v[e] = y;
 59     first[x] = e++;
 60 }
 61 bool dfs(int x) {
 62     int i;
 63     int y;
 64     vis[x] = true;
 65     for (i = first[x]; i != -1; i = next[i]) {
 66         y = v[i];
 67         if (!vis[y]) {
 68             if (dfs(y)) {
 69                 return true;
 70             }
 71         }
 72     }
 73     return x == des;
 74 }
 75 int main() {
 76     int n, m, k;
 77     int i, j, t;
 78     int tmp;
 79     int day;
 80     int tot;
 81     while (~scanf("%d%d%d", &n, &m, &k)) {
 82         cap.clear();
 83         for (i = 0; i < m; i++) {
 84             scanf("%d%d", &j, &tmp);
 85             cap.push_back(j);
 86             while (tmp--) {
 87                 scanf("%d", &j);
 88                 j += 3;
 89                 path[i].push_back(j);
 90             }
 91         }
 92         src = 3;
 93         des = 2;
 94         e = 0;
 95         memset(first, -1, sizeof(first));
 96         memset(vis, false, sizeof(vis));
 97         for (i = 0; i < m; i++) {
 98             for (j = 0; j < (int) path[i].size(); j++) {
 99                 addEdge(path[i][j], path[i][(j + 1) % path[i].size()]);
100                 addEdge(path[i][j + 1] % path[i].size(), path[i][j]);
101             }
102         }
103         if (dfs(src)) {
104             ans = 0;
105             memset(G, 0, sizeof(G));
106             src = 0;
107             des = 1;
108             tot = 2;
109             for (i = 0; i < m; i++) {
110                 ind[i].clear();
111                 pos[i].clear();
112                 ind[i].push_back(tot++);
113                 pos[i].push_back(path[i][0]);
114             }
115             for (i = 0; i < m; i++) {
116                 if (pos[i][0] == 3) {
117                     G[src][ind[i][0]] = oo;
118                 } else if (pos[i][0] == 2) {
119                     G[ind[i][0]][des] = oo;
120                 }
121             }
122             for (day = 1; ans < k; day++) {
123                 for (i = 0; i < m; i++) {
124                     ind[i].push_back(tot++);
125                     pos[i].push_back(path[i][day % (path[i].size())]);
126                     G[ind[i][day - 1]][ind[i][day]] = cap[i];
127                 }
128                 for (i = 0; i < m; i++) {
129                     for (j = 0; j < m; j++) {
130                         for (t = 0; t <= day; t++) {
131                             if (pos[j][t] == pos[i][day]) {
132                                 G[ind[j][t]][ind[i][day]] = oo;
133                             }
134                         }
135                     }
136                 }
137                 for (i = 0; i < m; i++) {
138                     if (pos[i][day] == 3) {
139                         G[src][ind[i][day]] = oo;
140                     } else if (pos[i][day] == 2) {
141                         G[ind[i][day]][des] = oo;
142                     }
143                 }
144                 V = tot;
145                 EdmondsKarp();
146             }
147             printf("%d\n", day - 1);
148         } else {
149             puts("0");
150         }
151     }
152     return 0;
153 }

 

（14）孤岛营救问题：分层图最短路径。 

 思路：

对钥匙种类状态压缩。dp[i][j][k]表示在(i,j)，钥匙种类为k的最短路。

View Code 
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<queue>
 4 #define MAXN 11
 5 #define oo 123456789
 6 using namespace std;
 7 int dp[MAXN][MAXN][1 << MAXN];
 8 int g[MAXN][MAXN][MAXN][MAXN];
 9 int mp[MAXN][MAXN];
10 int go[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
11 struct node {
12     int x;
13     int y;
14     int key;
15     int dis;
16 };
17 int n, m, p;
18 inline bool canMove(int x0, int y0, int x1, int y1, int key) {
19     int tmp = g[x0][y0][x1][y1];
20     if (tmp == -1) {
21         return true;
22     } else if (tmp == 0) {
23         return false;
24     } else if (key & (1 << (tmp - 1))) {
25         return true;
26     } else {
27         return false;
28     }
29 }
30 int bfs() {
31     node head, tmp;
32     queue<node> q;
33     int ans;
34     int i, j, k;
35     for (i = 1; i <= n; i++) {
36         for (j = 1; j <= m; j++) {
37             for (k = 0; k < (1 << p); k++)
38                 dp[i][j][k] = oo;
39         }
40     }
41     head.x = head.y = 1;
42     head.key = 0;
43     head.dis = 0;
44     q.push(head);
45     while (!q.empty()) {
46         head = q.front();
47         q.pop();
48         for (i = 0; i < 4; i++) {
49             tmp.x = head.x + go[i][0];
50             tmp.y = head.y + go[i][1];
51             if (tmp.x > 0 && tmp.x <= n && tmp.y > 0 && tmp.y <= m
52                     && canMove(head.x, head.y, tmp.x, tmp.y, head.key)) {
53                 tmp.dis = head.dis + 1;
54                 tmp.key = head.key;
55                 tmp.key |= mp[tmp.x][tmp.y];
56                 if (tmp.dis < dp[tmp.x][tmp.y][tmp.key]) {
57                     dp[tmp.x][tmp.y][tmp.key] = tmp.dis;
58                     q.push(tmp);
59                 }
60             }
61         }
62     }
63     ans = oo;
64     for (i = 0; i < (1 << p); i++) {
65         ans = min(ans, dp[n][m][i]);
66     }
67     if (ans == oo) {
68         return -1;
69     } else {
70         return ans;
71     }
72 }
73 int main() {
74     int i, j;
75     int x0, y0, x1, y1;
76     while (~scanf("%d%d%d", &n, &m, &p)) {
77         memset(g, -1, sizeof(g));
78         memset(mp, 0, sizeof(mp));
79         scanf("%d", &i);
80         while (i--) {
81             scanf("%d%d%d%d%d", &x0, &y0, &x1, &y1, &j);
82             g[x0][y0][x1][y1] = g[x1][y1][x0][y0] = j;
83         }
84         scanf("%d", &i);
85         while (i--) {
86             scanf("%d%d%d", &x0, &y0, &j);
87             mp[x0][y0] |= 1 << (j - 1);
88         }
89         printf("%d\n", bfs());
90     }
91     return 0;
92 }

 

（15）汽车加油行驶问题：分层图最短路径。 

 思路：

dp[i][j][k]表示在(i,j)，油量为k的最少花费。

View Code 
 1 #include<cstdio>
 2 #include<cstring>
 3 #include<queue>
 4 #define MAXN 110
 5 #define MAXM 15
 6 #define oo 123456789
 7 using namespace std;
 8 int dp[MAXN][MAXN][MAXM];
 9 int n, k, a, b, c;
10 int g[MAXN][MAXN];
11 struct node {
12     int x;
13     int y;
14     int gass;
15     int cost;
16 };
17 int go[4][2] = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
18 int spfa() {
19     int i, j, l;
20     int ans;
21     node head, tmp;
22     queue<node> q;
23     for (i = 0; i <= n; i++) {
24         for (j = 0; j <= n; j++) {
25             for (l = 0; l <= k; l++) {
26                 dp[i][j][l] = oo;
27             }
28         }
29     }
30     dp[1][1][k] = 0;
31     head.x = head.y = 1;
32     head.gass = k;
33     head.cost = 0;
34     q.push(head);
35     while (!q.empty()) {
36         head = q.front();
37         q.pop();
38         if (head.gass == 0) {
39             continue;
40         }
41         for (i = 0; i < 4; i++) {
42             tmp.x = head.x + go[i][0];
43             tmp.y = head.y + go[i][1];
44             if (tmp.x > 0 && tmp.x <= n && tmp.y > 0 && tmp.y <= n) {
45                 tmp.gass = head.gass - 1;
46                 tmp.cost = head.cost;
47                 if (tmp.x < head.x || tmp.y < head.y) {
48                     tmp.cost += b;
49                 }
50                 if (g[tmp.x][tmp.y]) {
51                     tmp.gass = k;
52                     tmp.cost += a;
53                 }
54                 if (tmp.cost < dp[tmp.x][tmp.y][tmp.gass]) {
55                     dp[tmp.x][tmp.y][tmp.gass] = tmp.cost;
56                     q.push(tmp);
57                 }
58                 if (!g[tmp.x][tmp.y]) {
59                     tmp.gass = k;
60                     tmp.cost += a + c;
61                     if (tmp.cost < dp[tmp.x][tmp.y][tmp.gass]) {
62                         dp[tmp.x][tmp.y][tmp.gass] = tmp.cost;
63                         q.push(tmp);
64                     }
65                 }
66             }
67         }
68     }
69     ans = oo;
70     for (i = 0; i <= k; i++) {
71         ans = min(ans, dp[n][n][i]);
72     }
73     return ans;
74 }
75 int main() {
76     int i, j;
77     while (~scanf("%d%d%d%d%d", &n, &k, &a, &b, &c)) {
78         for (i = 1; i <= n; i++) {
79             for (j = 1; j <= n; j++) {
80                 scanf("%d", &g[i][j]);
81             }
82         }
83         printf("%d\n", spfa());
84     }
85     return 0;
86 }

 

（16）数字梯形问题：最大权不相交路径。

 思路：

规则1：拆点，点与点之间流量都为1。

规则2：不拆点，点与点流量为1。

规则3：不拆点，点与点流量为无穷。

添加源点，汇点。求最小费用最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<vector>
  5 #define oo 0x7FFFFFFF
  6 #define MAXN 10010
  7 #define MAXM 1000010
  8 using namespace std;
  9 int V, n, m, e;
 10 int src, des;
 11 int link[MAXN], father[MAXN];
 12 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 13 int dis[MAXN];
 14 bool inq[MAXN];
 15 
 16 vector<int> arr[MAXN];
 17 vector<int> pos[MAXN];
 18 int size;
 19 void addEdge(int x, int y, int f, int c) {
 20     v[e] = y;
 21     flow[e] = f;
 22     cost[e] = c;
 23     next[e] = first[x];
 24     first[x] = e++;
 25 
 26     v[e] = x;
 27     flow[e] = 0;
 28     cost[e] = -c;
 29     next[e] = first[y];
 30     first[y] = e++;
 31 }
 32 bool SPFA() {
 33     int i, u;
 34     deque<int> q;
 35     memset(inq, false, sizeof(inq));
 36     for (i = 0; i <= V; i++) {
 37         dis[i] = oo;
 38     }
 39     dis[src] = 0;
 40     q.push_back(src);
 41     inq[src] = true;
 42     while (!q.empty()) {
 43         u = q.front();
 44         q.pop_front();
 45         inq[u] = false;
 46         for (i = first[u]; i != -1; i = next[i]) {
 47             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 48                 dis[v[i]] = dis[u] + cost[i];
 49                 father[v[i]] = u;
 50                 link[v[i]] = i;
 51                 if (!inq[v[i]]) {
 52                     inq[v[i]] = true;
 53                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 54                         q.push_front(v[i]);
 55                     } else {
 56                         q.push_back(v[i]);
 57                     }
 58                 }
 59             }
 60         }
 61     }
 62     return dis[des] != oo;
 63 }
 64 int MinCostMaxFlow() {
 65     int u;
 66     int ans;
 67     int tmp;
 68     for (ans = 0; SPFA();) {
 69         tmp = oo;
 70         for (u = des; u; u = father[u]) {
 71             tmp = min(tmp, flow[link[u]]);
 72         }
 73         for (u = des; u; u = father[u]) {
 74             flow[link[u]] -= tmp;
 75             flow[link[u] ^ 1] += tmp;
 76         }
 77         ans += tmp * dis[des];
 78     }
 79     return ans;
 80 }
 81 int getIndex(int x) {
 82     return 2 * x - 1;
 83 }
 84 void rule1() {
 85     int i, j;
 86     e = 0;
 87     src = 0;
 88     des = 2 * size + 1;
 89     V = des;
 90     memset(first, -1, sizeof(first));
 91     for (i = 1; i <= size; i++) {
 92         addEdge(getIndex(i), getIndex(i) + 1, 1, 0);
 93     }
 94     for (i = 0; i < (int) arr[1].size(); i++) {
 95         addEdge(src, getIndex(pos[1][i]), 1, -arr[1][i]);
 96     }
 97     for (i = 1; i < n; i++) {
 98         for (j = 0; j < (int) arr[i].size(); j++) {
 99             addEdge(getIndex(pos[i][j]) + 1, getIndex(pos[i + 1][j]), 1,
100                     -arr[i + 1][j]);
101             addEdge(getIndex(pos[i][j]) + 1, getIndex(pos[i + 1][j + 1]), 1,
102                     -arr[i + 1][j + 1]);
103         }
104     }
105     for (j = 0; j < (int) arr[n].size(); j++) {
106         addEdge(getIndex(pos[n][j]) + 1, des, 1, 0);
107     }
108     printf("%d\n", -MinCostMaxFlow());
109 }
110 void rule2() {
111     int i, j;
112     e = 0;
113     src = 0;
114     des = size + 1;
115     V = des;
116     memset(first, -1, sizeof(first));
117     for (i = 0; i < (int) arr[1].size(); i++) {
118         addEdge(src, pos[1][i], 1, -arr[1][i]);
119     }
120     for (i = 1; i < n; i++) {
121         for (j = 0; j < (int) arr[i].size(); j++) {
122             addEdge(pos[i][j], pos[i + 1][j], 1, -arr[i + 1][j]);
123             addEdge(pos[i][j], pos[i + 1][j + 1], 1, -arr[i + 1][j + 1]);
124         }
125     }
126     for (j = 0; j < (int) arr[n].size(); j++) {
127         addEdge(pos[n][j], des, oo, 0);
128     }
129     printf("%d\n", -MinCostMaxFlow());
130 }
131 void rule3() {
132     int i, j;
133     e = 0;
134     src = 0;
135     des = size + 1;
136     V = des;
137     memset(first, -1, sizeof(first));
138     for (i = 0; i < (int) arr[1].size(); i++) {
139         addEdge(src, pos[1][i], 1, -arr[1][i]);
140     }
141     for (i = 1; i < n; i++) {
142         for (j = 0; j < (int) arr[i].size(); j++) {
143             addEdge(pos[i][j], pos[i + 1][j], oo, -arr[i + 1][j]);
144             addEdge(pos[i][j], pos[i + 1][j + 1], oo, -arr[i + 1][j + 1]);
145         }
146     }
147     for (j = 0; j < (int) arr[n].size(); j++) {
148         addEdge(pos[n][j], des, oo, 0);
149     }
150     printf("%d\n", -MinCostMaxFlow());
151 }
152 int main() {
153     int i, j;
154     int tmp;
155     while (~scanf("%d%d", &m, &n)) {
156         size = 0;
157         for (i = 1; i <= n; i++) {
158             arr[i].clear();
159             pos[i].clear();
160             for (j = 0; j < m + i - 1; j++) {
161                 scanf("%d", &tmp);
162                 arr[i].push_back(tmp);
163                 pos[i].push_back(++size);
164             }
165         }
166         rule1();
167         rule2();
168         rule3();
169     }
170     return 0;
171 }

 

（17）运输问题：网络费用流量。

 思路：

1。最小费用最大流。

2。最大费用最大流，费用乘以-1，求最小费用最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<vector>
  5 #define oo 0x7FFFFFFF
  6 #define MAXL 1010
  7 #define MAXN 10010
  8 #define MAXM 1000010
  9 using namespace std;
 10 int V, n, m, e;
 11 int src, des;
 12 int link[MAXN], father[MAXN];
 13 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 14 int dis[MAXN];
 15 bool inq[MAXN];
 16 
 17 int a[MAXN];
 18 int b[MAXN];
 19 int c[MAXL][MAXL];
 20 void addEdge(int x, int y, int f, int c) {
 21     v[e] = y;
 22     flow[e] = f;
 23     cost[e] = c;
 24     next[e] = first[x];
 25     first[x] = e++;
 26 
 27     v[e] = x;
 28     flow[e] = 0;
 29     cost[e] = -c;
 30     next[e] = first[y];
 31     first[y] = e++;
 32 }
 33 bool SPFA() {
 34     int i, u;
 35     deque<int> q;
 36     memset(inq, false, sizeof(inq));
 37     for (i = 0; i <= V; i++) {
 38         dis[i] = oo;
 39     }
 40     dis[src] = 0;
 41     q.push_back(src);
 42     inq[src] = true;
 43     while (!q.empty()) {
 44         u = q.front();
 45         q.pop_front();
 46         inq[u] = false;
 47         for (i = first[u]; i != -1; i = next[i]) {
 48             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 49                 dis[v[i]] = dis[u] + cost[i];
 50                 father[v[i]] = u;
 51                 link[v[i]] = i;
 52                 if (!inq[v[i]]) {
 53                     inq[v[i]] = true;
 54                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 55                         q.push_front(v[i]);
 56                     } else {
 57                         q.push_back(v[i]);
 58                     }
 59                 }
 60             }
 61         }
 62     }
 63     return dis[des] != oo;
 64 }
 65 int MinCostMaxFlow() {
 66     int u;
 67     int ans;
 68     int tmp;
 69     for (ans = 0; SPFA();) {
 70         tmp = oo;
 71         for (u = des; u; u = father[u]) {
 72             tmp = min(tmp, flow[link[u]]);
 73         }
 74         for (u = des; u; u = father[u]) {
 75             flow[link[u]] -= tmp;
 76             flow[link[u] ^ 1] += tmp;
 77         }
 78         ans += tmp * dis[des];
 79     }
 80     return ans;
 81 }
 82 void calMinCostMaxFlow(int flag) {
 83     int i, j;
 84     src = 0;
 85     des = n + m + 1;
 86     V = des;
 87     e = 0;
 88     memset(first, -1, sizeof(first));
 89     for (i = 1; i <= m; i++) {
 90         addEdge(src, i, a[i], 0);
 91     }
 92     for (i = 1; i <= n; i++) {
 93         addEdge(m + i, des, b[i], 0);
 94     }
 95     for (i = 1; i <= m; i++) {
 96         for (j = 1; j <= n; j++) {
 97             addEdge(i, m + j, oo, c[i][j] * flag);
 98         }
 99     }
100     printf("%d\n", flag * MinCostMaxFlow());
101 }
102 int main() {
103     int i, j;
104     while (~scanf("%d%d", &m, &n)) {
105         for (i = 1; i <= m; i++) {
106             scanf("%d", &a[i]);
107         }
108         for (i = 1; i <= n; i++) {
109             scanf("%d", &b[i]);
110         }
111         for (i = 1; i <= m; i++) {
112             for (j = 1; j <= n; j++) {
113                 scanf("%d", &c[i][j]);
114             }
115         }
116         calMinCostMaxFlow(1);
117         calMinCostMaxFlow(-1);
118     }
119     return 0;
120 }

 

（18）分配问题：二分图最佳匹配。 

思路：

同（17）运输问题。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<vector>
  5 #define oo 0x7FFFFFFF
  6 #define MAXL 1010
  7 #define MAXN 10010
  8 #define MAXM 1000010
  9 using namespace std;
 10 int V, n, e;
 11 int src, des;
 12 int link[MAXN], father[MAXN];
 13 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 14 int dis[MAXN];
 15 bool inq[MAXN];
 16 
 17 int c[MAXL][MAXL];
 18 void addEdge(int x, int y, int f, int c) {
 19     v[e] = y;
 20     flow[e] = f;
 21     cost[e] = c;
 22     next[e] = first[x];
 23     first[x] = e++;
 24 
 25     v[e] = x;
 26     flow[e] = 0;
 27     cost[e] = -c;
 28     next[e] = first[y];
 29     first[y] = e++;
 30 }
 31 bool SPFA() {
 32     int i, u;
 33     deque<int> q;
 34     memset(inq, false, sizeof(inq));
 35     for (i = 0; i <= V; i++) {
 36         dis[i] = oo;
 37     }
 38     dis[src] = 0;
 39     q.push_back(src);
 40     inq[src] = true;
 41     while (!q.empty()) {
 42         u = q.front();
 43         q.pop_front();
 44         inq[u] = false;
 45         for (i = first[u]; i != -1; i = next[i]) {
 46             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 47                 dis[v[i]] = dis[u] + cost[i];
 48                 father[v[i]] = u;
 49                 link[v[i]] = i;
 50                 if (!inq[v[i]]) {
 51                     inq[v[i]] = true;
 52                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 53                         q.push_front(v[i]);
 54                     } else {
 55                         q.push_back(v[i]);
 56                     }
 57                 }
 58             }
 59         }
 60     }
 61     return dis[des] != oo;
 62 }
 63 int MinCostMaxFlow() {
 64     int u;
 65     int ans;
 66     int tmp;
 67     for (ans = 0; SPFA();) {
 68         tmp = oo;
 69         for (u = des; u; u = father[u]) {
 70             tmp = min(tmp, flow[link[u]]);
 71         }
 72         for (u = des; u; u = father[u]) {
 73             flow[link[u]] -= tmp;
 74             flow[link[u] ^ 1] += tmp;
 75         }
 76         ans += tmp * dis[des];
 77     }
 78     return ans;
 79 }
 80 void calMinCostMaxFlow(int flag) {
 81     int i, j;
 82     src = 0;
 83     des = n + n + 1;
 84     V = des;
 85     e = 0;
 86     memset(first, -1, sizeof(first));
 87     for (i = 1; i <= n; i++) {
 88         for (j = 1; j <= n; j++) {
 89             addEdge(i, n + j, oo, c[i][j] * flag);
 90         }
 91     }
 92     for (i = 1; i <= n; i++) {
 93         addEdge(src, i, 1, 0);
 94         addEdge(n + i, des, 1, 0);
 95     }
 96     printf("%d\n", flag * MinCostMaxFlow());
 97 }
 98 int main() {
 99     int i, j;
100     while (~scanf("%d", &n)) {
101         for (i = 1; i <= n; i++) {
102             for (j = 1; j <= n; j++) {
103                 scanf("%d", &c[i][j]);
104             }
105         }
106         calMinCostMaxFlow(1);
107         calMinCostMaxFlow(-1);
108     }
109     return 0;
110 }

 

（19）负载平衡问题：最小代价供求。 

思路：

1。向相邻的左右两个点连边，流量为oo，费用为1。

2。若一个点库存比平均值多a，则从源向该点连边，流量为a，费用为0。

3。若一个点库存比平均值少a，则从该点向汇连边，流量为a，费用为0。

4。求最小费用最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #define oo 123456
  5 #define MAXN 100010
  6 #define MAXM 1000010
  7 using namespace std;
  8 int V, n, m, e;
  9 int src, des;
 10 int lk[MAXN], father[MAXN];
 11 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 12 int dis[MAXN];
 13 bool inq[MAXN];
 14 
 15 int arr[MAXN];
 16 void addEdge(int x, int y, int f, int c) {
 17     v[e] = y;
 18     flow[e] = f;
 19     cost[e] = c;
 20     next[e] = first[x];
 21     first[x] = e++;
 22 
 23     v[e] = x;
 24     flow[e] = 0;
 25     cost[e] = -c;
 26     next[e] = first[y];
 27     first[y] = e++;
 28 }
 29 bool SPFA() {
 30     int i, u;
 31     deque<int> q;
 32     memset(inq, false, sizeof(inq));
 33     for (i = 0; i <= V; i++) {
 34         dis[i] = oo;
 35     }
 36     dis[src] = 0;
 37     q.push_back(src);
 38     inq[src] = true;
 39     while (!q.empty()) {
 40         u = q.front();
 41         q.pop_front();
 42         inq[u] = false;
 43         for (i = first[u]; i != -1; i = next[i]) {
 44             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 45                 dis[v[i]] = dis[u] + cost[i];
 46                 father[v[i]] = u;
 47                 lk[v[i]] = i;
 48                 if (!inq[v[i]]) {
 49                     inq[v[i]] = true;
 50                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 51                         q.push_front(v[i]);
 52                     } else {
 53                         q.push_back(v[i]);
 54                     }
 55                 }
 56             }
 57         }
 58     }
 59     return dis[des] != oo;
 60 }
 61 int MinCostMaxFlow() {
 62     int u;
 63     int ans;
 64     int tmp;
 65     for (ans = 0; SPFA();) {
 66         tmp = oo;
 67         for (u = des; u; u = father[u]) {
 68             tmp = min(tmp, flow[lk[u]]);
 69         }
 70         for (u = des; u; u = father[u]) {
 71             flow[lk[u]] -= tmp;
 72             flow[lk[u] ^ 1] += tmp;
 73         }
 74         ans += tmp * dis[des];
 75     }
 76     return ans;
 77 }
 78 int main() {
 79     int i, j;
 80     int sum;
 81     while (~scanf("%d", &n)) {
 82         e = 0;
 83         src = 0;
 84         des = n + 1;
 85         V = des;
 86         memset(first, -1, sizeof(first));
 87         sum = 0;
 88         for (i = 1; i <= n; i++) {
 89             scanf("%d", &arr[i]);
 90             sum += arr[i];
 91         }
 92         sum /= n;
 93         for (i = 1; i <= n; i++) {
 94             arr[i] -= sum;
 95             if (arr[i] > 0) {
 96                 addEdge(src, i, arr[i], 0);
 97             } else if (arr[i] < 0) {
 98                 addEdge(i, des, -arr[i], 0);
 99             }
100             j = i + 1;
101             if (j > n) {
102                 j = 1;
103             }
104             addEdge(i, j, oo, 1);
105             addEdge(j, i, oo, 1);
106             j = i - 1;
107             if (j < 1) {
108                 j = n;
109             }
110             addEdge(i, j, oo, 1);
111             addEdge(j, i, oo, 1);
112         }
113         printf("%d\n", MinCostMaxFlow());
114     }
115     return 0;
116 }

 

（20）深海机器人问题：线性规划网络优化。 

思路：

1。每个权值只能取一次，流量设为1。

2。每条路径可以取多次，流量设为oo。

3。最大费用最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #define oo 123456
  5 #define MAXN 100010
  6 #define MAXM 1000010
  7 using namespace std;
  8 int V, n, m, e;
  9 int src, des;
 10 int lk[MAXN], father[MAXN];
 11 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 12 int dis[MAXN];
 13 bool inq[MAXN];
 14 
 15 void addEdge(int x, int y, int f, int c) {
 16     v[e] = y;
 17     flow[e] = f;
 18     cost[e] = c;
 19     next[e] = first[x];
 20     first[x] = e++;
 21 
 22     v[e] = x;
 23     flow[e] = 0;
 24     cost[e] = -c;
 25     next[e] = first[y];
 26     first[y] = e++;
 27 }
 28 bool SPFA() {
 29     int i, u;
 30     deque<int> q;
 31     memset(inq, false, sizeof(inq));
 32     for (i = 0; i <= V; i++) {
 33         dis[i] = oo;
 34     }
 35     dis[src] = 0;
 36     q.push_back(src);
 37     inq[src] = true;
 38     while (!q.empty()) {
 39         u = q.front();
 40         q.pop_front();
 41         inq[u] = false;
 42         for (i = first[u]; i != -1; i = next[i]) {
 43             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 44                 dis[v[i]] = dis[u] + cost[i];
 45                 father[v[i]] = u;
 46                 lk[v[i]] = i;
 47                 if (!inq[v[i]]) {
 48                     inq[v[i]] = true;
 49                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 50                         q.push_front(v[i]);
 51                     } else {
 52                         q.push_back(v[i]);
 53                     }
 54                 }
 55             }
 56         }
 57     }
 58     return dis[des] != oo;
 59 }
 60 int MinCostMaxFlow() {
 61     int u;
 62     int ans;
 63     int tmp;
 64     for (ans = 0; SPFA();) {
 65         tmp = oo;
 66         for (u = des; u; u = father[u]) {
 67             tmp = min(tmp, flow[lk[u]]);
 68         }
 69         for (u = des; u; u = father[u]) {
 70             flow[lk[u]] -= tmp;
 71             flow[lk[u] ^ 1] += tmp;
 72         }
 73         ans += tmp * dis[des];
 74     }
 75     return ans;
 76 }
 77 int main() {
 78     int a, b;
 79     int p, q;
 80     int i, j;
 81     int x, y, val;
 82     while (~scanf("%d%d%d%d", &a, &b, &p, &q)) {
 83         e = 0;
 84         src = 0;
 85         des = (p + 1) * (q + 1) + 1;
 86         V = des;
 87         memset(first, -1, sizeof(first));
 88         for (i = 0; i <= p; i++) {
 89             for (j = 1; j <= q; j++) {
 90                 scanf("%d", &x);
 91                 addEdge(i * (q + 1) + j, i * (q + 1) + j + 1, 1, -x);
 92                 addEdge(i * (q + 1) + j, i * (q + 1) + j + 1, oo, 0);
 93             }
 94         }
 95         for (i = 0; i <= q; i++) {
 96             for (j = 1; j <= p; j++) {
 97                 scanf("%d", &x);
 98                 addEdge((j - 1) * (q + 1) + i + 1, j * (q + 1) + i + 1, 1, -x);
 99                 addEdge((j - 1) * (q + 1) + i + 1, j * (q + 1) + i + 1, oo, 0);
100             }
101         }
102         while (a--) {
103             scanf("%d%d%d", &val, &y, &x);
104             addEdge(src, y * (q + 1) + x + 1, val, 0);
105         }
106         while (b--) {
107             scanf("%d%d%d", &val, &y, &x);
108             addEdge(y * (q + 1) + x + 1, des, val, 0);
109         }
110         printf("%d\n", -MinCostMaxFlow());
111     }
112 }

 

（21）最长k可重区间集问题：最大权不相交路径。 

思路：

1。对所有端点排序后，离散化。

2。源到1，流量为k，费用为0。最后一个点到汇，流量为oo，费用为0。

3。若有区间[x,y]，则x向y连边，流量为1，费用为x-y。

4。最大费用最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<queue>
  4 #include<algorithm>
  5 #define oo 123456
  6 #define MAXN 100010
  7 #define MAXM 1000010
  8 using namespace std;
  9 int V, n, m, e;
 10 int src, des;
 11 int lk[MAXN], father[MAXN];
 12 int first[MAXN], cost[MAXM], flow[MAXM], next[MAXM], v[MAXM];
 13 int dis[MAXN];
 14 bool inq[MAXN];
 15 
 16 int arr[MAXN];
 17 int size;
 18 struct point {
 19     int x, y;
 20 } p[MAXN];
 21 void addEdge(int x, int y, int f, int c) {
 22     v[e] = y;
 23     flow[e] = f;
 24     cost[e] = c;
 25     next[e] = first[x];
 26     first[x] = e++;
 27 
 28     v[e] = x;
 29     flow[e] = 0;
 30     cost[e] = -c;
 31     next[e] = first[y];
 32     first[y] = e++;
 33 }
 34 bool SPFA() {
 35     int i, u;
 36     deque<int> q;
 37     memset(inq, false, sizeof(inq));
 38     for (i = 0; i <= V; i++) {
 39         dis[i] = oo;
 40     }
 41     dis[src] = 0;
 42     q.push_back(src);
 43     inq[src] = true;
 44     while (!q.empty()) {
 45         u = q.front();
 46         q.pop_front();
 47         inq[u] = false;
 48         for (i = first[u]; i != -1; i = next[i]) {
 49             if (flow[i] && dis[v[i]] > dis[u] + cost[i]) {
 50                 dis[v[i]] = dis[u] + cost[i];
 51                 father[v[i]] = u;
 52                 lk[v[i]] = i;
 53                 if (!inq[v[i]]) {
 54                     inq[v[i]] = true;
 55                     if (!q.empty() && dis[v[i]] <= dis[q.front()]) {
 56                         q.push_front(v[i]);
 57                     } else {
 58                         q.push_back(v[i]);
 59                     }
 60                 }
 61             }
 62         }
 63     }
 64     return dis[des] != oo;
 65 }
 66 int MinCostMaxFlow() {
 67     int u;
 68     int ans;
 69     int tmp;
 70     for (ans = 0; SPFA();) {
 71         tmp = oo;
 72         for (u = des; u; u = father[u]) {
 73             tmp = min(tmp, flow[lk[u]]);
 74         }
 75         for (u = des; u; u = father[u]) {
 76             flow[lk[u]] -= tmp;
 77             flow[lk[u] ^ 1] += tmp;
 78         }
 79         ans += tmp * dis[des];
 80     }
 81     return ans;
 82 }
 83 int main() {
 84     int i;
 85     int m;
 86     int x, y;
 87     while (~scanf("%d%d", &n, &m)) {
 88         e = 0;
 89         src = 0;
 90         des = n + n + 1;
 91         V = des;
 92         memset(first, -1, sizeof(first));
 93         size = 0;
 94         for (i = 0; i < n; i++) {
 95             scanf("%d%d", &p[i].x, &p[i].y);
 96             arr[size++] = p[i].x;
 97             arr[size++] = p[i].y;
 98         }
 99         sort(arr, arr + size);
100         size = unique(arr, arr + size) - arr;
101         addEdge(src, 1, m, 0);
102         addEdge(size, des, oo, 0);
103         for (i = 2; i <= size; i++) {
104             addEdge(i - 1, i, oo, 0);
105         }
106         for (i = 0; i < n; i++) {
107             x = lower_bound(arr, arr + size, p[i].x) - arr + 1;
108             y = lower_bound(arr, arr + size, p[i].y) - arr + 1;
109             addEdge(x, y, 1, p[i].x - p[i].y);
110         }
111         printf("%d\n", -MinCostMaxFlow());
112     }
113     return 0;
114 }

 

（24）骑士共存问题：二分图最大独立集。

思路：

1。冲突的位置相互连边。

2.。添加源，汇。

3。求最大流。

View Code 
  1 #include<cstdio>
  2 #include<cstring>
  3 #include<vector>
  4 #define MAXL 210
  5 #define MAXN 100010
  6 #define MAXM 1000010
  7 #define oo 0x7FFFFFFF
  8 using namespace std;
  9 int first[MAXN], next[MAXM], v[MAXM], cost[MAXM], e;
 10 int n;
 11 int src, des;
 12 bool flag[MAXL][MAXL];
 13 int go[][2] = { { 1, 2 }, { 1, -2 }, { -1, 2 }, { -1, -2 }, { 2, 1 }, { 2, -1 },
 14         { -2, 1 }, { -2, -1 } };
 15 inline void addEdge(int x, int y, int val) {
 16     v[e] = y;
 17     cost[e] = val;
 18     next[e] = first[x];
 19     first[x] = e++;
 20 
 21     v[e] = x;
 22     cost[e] = 0;
 23     next[e] = first[y];
 24     first[y] = e++;
 25 }
 26 int SAP() {
 27     int pre[MAXN], cur[MAXN], dis[MAXN], gap[MAXN];
 28     int flow = 0;
 29     int aug = oo;
 30     int x, y;
 31     bool flag;
 32     for (int i = 0; i < n; i++) {
 33         cur[i] = first[i];
 34         gap[i] = dis[i] = 0;
 35     }
 36     gap[src] = n;
 37     x = pre[src] = src;
 38     while (dis[src] < n) {
 39         flag = false;
 40         for (int &j = cur[x]; j != -1; j = next[j]) {
 41             y = v[j];
 42             if (cost[j] > 0 && dis[x] == dis[y] + 1) {
 43                 flag = true;
 44                 aug = min(aug, cost[j]);
 45                 pre[y] = x;
 46                 x = y;
 47                 if (x == des) {
 48                     flow += aug;
 49                     while (x != src) {
 50                         x = pre[x];
 51                         cost[cur[x]] -= aug;
 52                         cost[cur[x] ^ 1] += aug;
 53                     }
 54                     aug = oo;
 55                 }
 56                 break;
 57             }
 58         }
 59         if (flag) {
 60             continue;
 61         }
 62         int tmp = n;
 63         for (int j = first[x]; j != -1; j = next[j]) {
 64             y = v[j];
 65             if (cost[j] > 0 && dis[y] < tmp) {
 66                 tmp = dis[y];
 67                 cur[x] = j;
 68             }
 69         }
 70         if ((--gap[dis[x]]) == 0) {
 71             break;
 72         }
 73         gap[dis[x] = tmp + 1]++;
 74         x = pre[x];
 75     }
 76     return flow;
 77 }
 78 int getIndex(int x, int y) {
 79     return (x - 1) * n + y;
 80 }
 81 int main() {
 82     int m;
 83     int i, j, k;
 84     int x, y;
 85     int ans;
 86     while (~scanf("%d%d", &n, &m)) {
 87         src = 0;
 88         des = 2 * n * n + 1;
 89         e = 0;
 90         memset(first, -1, sizeof(first));
 91         memset(flag, false, sizeof(flag));
 92         for (i = 0; i < m; i++) {
 93             scanf("%d%d", &x, &y);
 94             flag[x][y] = true;
 95         }
 96         for (i = 1; i <= n; i++) {
 97             for (j = 1; j <= n; j++) {
 98                 if (flag[i][j]) {
 99                     continue;
100                 }
101                 addEdge(src, getIndex(i, j), 1);
102                 addEdge(n * n + getIndex(i, j), des, 1);
103                 for (k = 0; k < 8; k++) {
104                     x = i + go[k][0];
105                     y = j + go[k][1];
106                     if (x > 0 && x <= n && y > 0 && y <= n && !flag[x][y]) {
107                         addEdge(getIndex(i, j), n * n + getIndex(x, y), 1);
108                     }
109                 }
110             }
111         }
112         ans = n * n - m;
113         n = des + 1;
114         printf("%d\n", ans - SAP() / 2);
115     }
116     return 0;
117 }

 

posted on 2013-05-08 22:04  DrunBee  阅读(4264)  评论(3)  编辑  收藏  举报