C++博客-y @ The Angry Teletubbies-文章分类-Graph Theory

hdoj 4307 Matrix - 最大流最小割

y @ The Angry Teletubbies — Fri, 27 Jul 2012 12:06:00 GMT

【题意】：给出一个矩阵方程D = (A * B - C) * A^T，已知矩阵B[n*n]和矩阵C[1*n]，现在要你求一个01矩阵A[1*n]使得D最大，问D最大是多少。

【题解】：这个题目可以转化为poj 3469.
对于矩阵B来说，选到某一列i，那么也要选到C[i]。于是可以转化一下问题，对于B的每一列都存在选与不选的情况，而这些情况刚刚好对应着矩阵A。
那么我们假设先把B的所有列都选上，再通过调整。如果B某一列i不选，那么代价是这一列的和，如果选上，代价就是C[i]，对于选择了列i而没选列j这种情况，我们的代价是B[i][j]，于是我们可以把问题转化为最小割。
把每列抽象成一个结点。
源点s连边每列，容量为这一列的和；
每一列向汇点t连边，容量为C[i]；
列i向列j连边，容量为b[j][i]；
最后答案就是 ∑b[i][j] - mincut / maxflow.

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 #define pb push_back
17 #define mp make_pair
18 #define fi first
19 #define se second
20 #define sof(x) sizeof(x)
21 #define lc(x) (x << 1)
22 #define rc(x) (x << 1 | 1)
23 #define lowbit(x) (x & (-x))
24 #define ll long long
25 #define maxn 1050
26 #define maxm 3000000
27 const int inf = 1 << 30;
28 int n, m, s, t;
29 int b[maxn][maxn], c[maxn], cc[maxn];
30 int eh[maxn], low[maxn], dist[maxn], pre[maxn], cur[maxn], tot, cnt[maxn];
31 struct Edge {
32     int u, v, cap, flow, next;
33 }et[maxm];
34 void init() {
35     tot = 0;
36     memset(eh, -1, sizeof(eh));
37 }
38 void add(int u, int v, int cap, int flow) {
39     Edge e = {u, v, cap, flow, eh[u]};
40     et[tot] = e;
41     eh[u] = tot++;
42 }
43 void addedge(int u, int v, int cap) {
44     add(u, v, cap, 0), add(v, u, 0, 0);
45 }
46 int isap(int s, int t, int n){
47     int u, v, now, flow = 0;
48     memset(dist, 0, sizeof(dist));
49     memset(low, 0, sizeof(low));
50     memset(cnt, 0, sizeof(cnt));
51     for(u = 0 ; u <= n ; u ++) cur[u] = eh[u];
52     low[s] = inf, cnt[0] = n, u = s;
53     while(dist[s] < n) {
54         for(now = cur[u]; now != -1; now = et[now].next)
55             if(et[now].cap - et[now].flow && dist[u] == dist[ v = et[now].v ] + 1 ) break;
56         if(now != -1) {
57             cur[u] = pre[v] = now;
58             low[v] = min(et[now].cap - et[now].flow, low[u]);
59             u = v;
60             if(u == t) {
61                 for(; u != s; u = et[pre[u]].u){
62                     et[pre[u]].flow += low[t];
63                     et[pre[u]^1].flow -= low[t];
64                 }
65                 flow += low[t]; low[s] = inf;
66             }
67         } else {
68             if(--cnt[dist[u]] == 0) break;
69             dist[u] = n, cur[u] = eh[u];
70             for(now = eh[u]; now != -1; now = et[now].next)
71                 if(et[now].cap - et[now].flow && dist[u] > dist[et[now].v] + 1)
72                     dist[u] = dist[ et[now].v ] + 1;
73             cnt[dist[u]]++;
74             if(u != s) u = et[pre[u]].u;
75         }
76     }
77     return flow;
78 }
79
80 void build() {
81     s = 0, t = n + 1;
82     for(int i = 1; i <= n; i++) addedge(s, i, cc[i]), addedge(i, t, c[i]);
83     for(int i = 1; i <= n; i++)
84         for(int j = 1; j <= n; j++)
85             if(i != j) addedge(j, i, b[i][j]);
86 }
87
88 int main() {
89     int T;
90     scanf("%d", &T);
91     while(T--) {
92         init();
93         scanf("%d", &n);
94         int sum = 0;
95         memset(cc, 0, sizeof(cc));
96         for(int i = 1; i <= n; i++)
97             for(int j = 1; j <= n; j++) {
98                 scanf("%d", &b[i][j]);
99                 sum += b[i][j];
100                 cc[j] += b[i][j];
101             }
102         for(int i = 1; i <= n; i++) scanf("%d", &c[i]);
103         build();
104         int cut = isap(s, t, n + 2);
105         printf("%d\n", sum - cut);
106
107     }
108     return 0;
109 }
110

y @ The Angry Teletubbies 2012-07-27 20:06 发表评论

hdoj 4313 Matrix - 最大生成森林

y @ The Angry Teletubbies — Fri, 27 Jul 2012 10:29:00 GMT

【题意】：给出一棵树，每条边都有一个价值，现在某k个点有炸弹，要你切断某些边，使得任意两个炸弹不连通。

【题解】：这题可以用树dp去解，但是有一种更巧妙的解法。
删边问题可以转换为求最大生成森林，把边按大到小排序，然后把所有炸弹结点指向同一集合。枚举边，用并查集去判断添加这条边是否会导致两个炸弹连通。
其实只是一个Kruskal算法的应用，不过转换确实巧妙。

【代码】：

y @ The Angry Teletubbies 2012-07-27 18:29 发表评论

hdoj 3572 Task Schedule - 最大流

y @ The Angry Teletubbies — Wed, 25 Jul 2012 07:24:00 GMT

【题意】：给出n个任务和m个机器，每个机器每天只能运行一个任务。对于每个任务，有三个属性p，s，e，表示这个任务至少要在s天后开始运行，至多要在e天前结束运行，并且需要运行p天。问是否存在一种方案使得这n个任务都完成。

【题解】：用网络流来判断是否可行。
把每个任务看成一个点，s到每个任务连边，容量为任务需要运行的天数。
把每天看成一个点，每天向t连边，容量为m，表示一天最多运行m个任务。
每个任务都向s-e天连边，容量为1，表示这个任务可以在这些天运行。
最后判断最大流是否等于所有任务需要运行的天数总和即可。

【代码】：

y @ The Angry Teletubbies 2012-07-25 15:24 发表评论

uva 4039 Sightseeing - KM + 二分图最优匹配

y @ The Angry Teletubbies — Sat, 21 Jul 2012 17:47:00 GMT

【题意】：给出一副无向图，n个点m条边，每条边上都有一个权值，表示通过这条边的费用。现在问任选一个点i开始遍历完所有边至少一次回到i的最小费用是多少。

【题解】：先累加一次所有边的费用sum，然后保留奇度的点，对于每两个奇度的点连边，费用为点到点的最短距离，求一次最小匹配res。最后答案为sum+res。
对于用km求最小匹配，把边权取反再加上一个inf，最后减回去即可，没边的权值为0。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 #define pb push_back
17 #define mp make_pair
18 #define fi first
19 #define se second
20 #define sof(x) sizeof(x)
21 #define lc(x) (x << 1)
22 #define rc(x) (x << 1 | 1)
23 #define lowbit(x) (x & (-x))
24 #define ll long long
25 #define MAX 110
26 #define maxn 110
27 int n, m;
28 const int inf = 100000000;
29 int g[MAX][MAX];
30
31 int d[MAX];
32 int maz[maxn][maxn], lx[maxn], ly[maxn], match[maxn], sy[maxn], slack[maxn], sx[maxn];
33 int nx, ny;
34 int q[maxn], tot;
35 bool dfs(int t) {
36     sx[t] = 1;
37     for (int i = 1; i <= ny; ++i) {
38         if (sy[i])continue;
39         if (maz[t][i] == lx[t] + ly[i]) {
40             sy[i] = 1;
41             if (match[i] == -1 || dfs(match[i])) {
42                 match[i] = t;
43                 return 1;
44             }
45         } else slack[i] = min(slack[i], lx[t] + ly[i] - maz[t][i]);
46     }
47     return 0;
48 }
49 void Change() {
50     int Min = inf;
51     for (int i = 1; i <= ny; ++i)
52         if (!sy[i]) Min = min(Min, slack[i]);
53     for (int i = 1; i <= nx; ++i)
54         if (sx[i]) lx[i] -= Min;
55     for (int i = 1; i <= ny; ++i) {
56         if (sy[i]) ly[i] += Min;
57         else slack[i] -= Min;
58     }
59 }
60 int KM() {
61     int ans = 0;
62     memset(match, -1, sizeof (match));
63     for (int i = 1; i <= nx; ++i) {
64         for (int j = 1; j <= ny; ++j)
65             slack[j] = inf;
66         while (1) {
67             memset(sy, 0, sizeof (sy));
68             memset(sx, 0, sizeof (sx));
69             if (dfs(i)) break;
70             Change();
71         }
72     }
73     for (int i = 1; i <= ny; ++i)
74         if(match[i] != -1) ans += inf - maz[match[i]][i];
75     return ans / 2;
76 }
77 void build() {
78     memset(maz, 0, sizeof (maz));
79     nx = tot;
80     ny = tot;
81     for(int i = 0; i < tot; i++)
82         for(int j = 0; j < tot; j++) {
83             if(i != j) maz[i+1][j+1] = inf - g[q[i]][q[j]];
84         }
85     memset(ly, 0, sizeof (ly));
86     for (int i = 1; i <= nx; ++i) {
87         lx[i] = -inf;
88         for (int j = 1; j <= ny; ++j)
89             lx[i] = max(lx[i], maz[i][j]);
90     }
91 }
92
93 int floyd() {
94     for(int k = 1; k <= n; k++)
95         for(int i = 1; i <= n; i++)
96             for(int j = 1; j <= n; j++)
97                 g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
98 }
99
100 int main() {
101     int T, x;
102     scanf("%d", &T);
103     while(T--) {
104         scanf("%d%d", &n, &m);
105         for(int i = 1; i <= n; i++) {
106             for(int j = 1; j <= n; j++)
107                 g[i][j] = inf;
108             g[i][i] = 0;
109         }
110         int ans = 0;
111         memset(d, 0, sizeof(d));
112         for(int i = 0; i < m; i++) {
113             int u, v, w;
114             scanf("%d%d%d", &u, &v, &w);
115             ans += w;
116             g[u][v] = g[v][u] = w;
117             d[u]++, d[v]++;
118         }
119         tot = 0;
120         for(int i = 1; i <= n; i++)
121             if(d[i] & 1) q[tot++] = i;
122         floyd();
123         build();
124         int res = KM();
125         cout << ans + res << endl;
126         scanf("%d", &x);
127         if(x == -1) break;
128     }
129
130     return 0;
131 }
132

y @ The Angry Teletubbies 2012-07-22 01:47 发表评论

uva 4041 Eventown Problem - 全局最小割

y @ The Angry Teletubbies — Sat, 21 Jul 2012 17:05:00 GMT

【题意】：给出n个人，f[i][j]表示他们的友好程度，现在要把这n个人分成两组，使得所有人的开心程度之和最大，既∑∑(-1)^1-s[i][j]f[i][j]最大化。其中，s[i][j]表示i和j是否同一组。

【题解】：先假设所有人都在同一组，sum = ∑f[i][j]，然后我们需要改变某些人的关系使得n个人分成两组且代价最小，这样问题就转为求一个无向图的全局最小割。
最后答案为sum - 4 * mincut。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21
22 #define maxn 100
23 const int inf = 1 << 27;
24 int maz[maxn][maxn];
25 int n, m;
26
27 int StoerWagner(int n) {//n 为点数
28     int v[maxn], dist[maxn];
29     bool visit[maxn];
30     int cut = inf;
31     for(int i = 0; i < n; i++) v[i] = i;
32     while(n > 1) {
33         int k = 1, pre = 0;
34         for(int i = 1; i < n; i++) {
35             dist[v[i]] = maz[v[0]][v[i]];
36             if(dist[v[i]] > dist[v[k]]) k = i;
37         }
38         memset(visit, false, sizeof(visit));
39         visit[v[0]] = true;
40         for(int i = 1; i < n; i++) {
41             if(i == n - 1) {
42                 cut = min(cut, dist[v[k]]);
43                 for(int j = 0; j < n; j++) {
44                     maz[v[pre]][v[j]] += maz[v[j]][v[k]];
45                     maz[v[j]][v[pre]] += maz[v[j]][v[k]];
46                 }
47                 v[k] = v[--n];
48             }
49             visit[v[k]] = true;
50             pre = k, k = -1;
51             for(int j = 1; j < n; j++) {
52                 if(!visit[v[j]]) {
53                     dist[v[j]] += maz[v[pre]][v[j]];
54                     if(k == -1 || dist[v[k]] < dist[v[j]])
55                         k = j;
56                 }
57             }
58         }
59     }
60     return cut;
61 }
62
63 int main() {
64     int T;
65     while(scanf("%d", &T), T) {
66         while(T--) {
67             scanf("%d%d", &n, &m);
68             memset(maz, 0, sizeof(maz));
69             int sum = 0;
70             for(int i = 0; i < n; i++)
71                 for(int j = 0; j < n; j++) {
72                     scanf("%d", &maz[i][j]);
73                     sum += maz[i][j];
74                 }
75             int ans = sum - 4 * StoerWagner(n);
76             cout << ans << endl;
77         }
78     }
79     return 0;
80 }
81

y @ The Angry Teletubbies 2012-07-22 01:05 发表评论

hdoj 3622 Bomb Game - 二分 + 2sat

y @ The Angry Teletubbies — Sat, 21 Jul 2012 05:47:00 GMT

【题意】：给定n组点，每组两个点，要在每组中选一个点安置一个定时炸弹，这个炸弹的范围是以炸弹的位置为圆心的一个圆，半径由你控制。要求安置的n个炸弹不能相互攻击，问最小的圆的半径最大为多少。

【题解】：很容易想到二分，然后每组有两个点只能选一个，就是一个2sat问题喇。二分答案用2sat判断即可。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 typedef pair<double, double> pdd;
17 #define pb push_back
18 #define mp make_pair
19 #define fi first
20 #define se second
21 #define sof(x) sizeof(x)
22 #define lc(x) (x << 1)
23 #define rc(x) (x << 1 | 1)
24 #define lowbit(x) (x & (-x))
25 #define ll long long
26 #define eps 1e-6
27 #define maxn 550
28 int n, nn;
29 int eh[maxn], tot;
30 vector<int> vec[maxn];
31 pdd p[maxn];
32
33 int dfn[maxn], low[maxn], Dindex, instack[maxn], belong[maxn], scc;
34 int s[maxn], top;
35
36 double getdist(const pdd &a, const pdd &b) {
37     return sqrt((a.fi - b.fi) * (a.fi - b.fi) + (a.se - b.se) * (a.se - b.se));
38 }
39
40 void dfs(int u) {
41     int v;
42     dfn[u] = low[u] = ++Dindex;
43     s[++top] = u, instack[u] = true;
44     int size = vec[u].size();
45     for(int i = 0; i < size; i++) {
46         v = vec[u][i];
47         if(!dfn[v]) dfs(v), low[u] = min(low[u], low[v]);
48         else if(instack[v]) low[u] = min(low[u], dfn[v]);
49      }
50     if(dfn[u] == low[u]) {
51         scc++;
52         do {
53             v = s[top--];
54             instack[v] = false;
55             belong[v] = scc;
56         }while(v != u);
57     }
58 }
59
60 void tarjan() {
61     top = scc = Dindex = 0;
62     memset(dfn, 0, sizeof(dfn));
63     memset(instack, 0, sizeof(instack));
64     for (int i = 0; i < (nn << 1); i++)
65         if(!dfn[i]) dfs(i);
66 }
67
68 bool isOK() {
69     for(int i = 0; i < nn; i++)
70         if(belong[i] == belong[i+nn]) return false;
71     return true;
72 }
73
74 void build(double limit) {
75     for(int i = 0; i < (nn << 1); i++) vec[i].clear();
76     for(int i = 0; i < n; i++) {
77         int a = i << 1, b = i << 1 | 1;
78         vec[a].pb(b + nn), vec[b].pb(a + nn);
79         vec[a+nn].pb(b), vec[b+nn].pb(a);
80         for(int j = 0; j < i; j++) {
81             int c = j << 1, d = j << 1 | 1;
82             if(getdist(p[a], p[c]) + eps < limit) {
83                 vec[a].pb(c+nn), vec[a].pb(d);
84                 vec[c].pb(a+nn), vec[c].pb(b);
85             }
86             if(getdist(p[a], p[d]) + eps < limit) {
87                 vec[a].pb(d+nn), vec[a].pb(c);
88                 vec[d].pb(a+nn), vec[d].pb(b);
89             }
90             if(getdist(p[b], p[c]) + eps < limit) {
91                 vec[b].pb(c+nn), vec[b].pb(d);
92                 vec[c].pb(b+nn), vec[c].pb(a);
93             }
94             if(getdist(p[b], p[d]) + eps < limit) {
95                 vec[b].pb(d+nn), vec[b].pb(c);
96                 vec[d].pb(b+nn), vec[d].pb(a);
97             }
98         }
99     }
100 }
101
102 bool check(double limit) {
103     build(limit);
104     tarjan();
105     return isOK();
106 }
107
108 void solve() {
109     double l = 0.0, r = 1e6;
110     double ans;
111     while(l + eps < r) {
112         double mid = (l + r) / 2.0;
113         if(check(mid * 2)) ans = mid, l = mid;
114         else r = mid;
115     }
116     printf("%.2f\n", ans);
117 }
118
119 int main() {
120     while(~scanf("%d", &n)) {
121         nn = n << 1;
122         for(int i = 0; i < nn; i++) scanf("%lf%lf", &p[i].fi, &p[i].se);
123         solve();
124     }
125     return 0;
126 }
127

y @ The Angry Teletubbies 2012-07-21 13:47 发表评论

uva 4263 Early-Morning Pickup - 两次dp预处理 + 费用流

y @ The Angry Teletubbies — Fri, 20 Jul 2012 03:35:00 GMT

【题意】：给出一个无向图，边上的权值为通过这条边的时间。有四类点，分别代表客服的家，客服的办公室，客户的家和维修站，客服数量大于客户数量。现在要求对于每个客户都要有一个客服到达他的家然后再到达维修站，每个客服只能服务一个客户，最后所有的客服都要回到他们各自的办公室（有些客服是直接回办公室的）。问所有客服回到办公室的平均时间最少是多少。

【题解】：先用floyd预处理点到点的最短路。
然后设状态dp[i][j]表示第i个客服服务完第j个客户后回到自己的办公室的最短时间。
因为题目要求的是平均时间最少，也就是总时间最少。
可以想到用费用流模型：
源点s向每个客服连边，容量为1，费用为0；
每个客户向汇点t连边，容量为1，费用为0；
每个客服向每个客户连边，容量为1，费用为dp[i][j]；
增加一个虚拟结点x，表示有些客服是直接回办公室的。每个客服向s连边，容量为1，费用为每个人直接回办公室的时间。
可以想到，最后有r - c个客服直接回办公室，所以x连边到汇点t，容量为r-c，费用为0.

最后求最小费用流即为答案。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 #define pb push_back
17 #define mp make_pair
18 #define fi first
19 #define se second
20 #define sof(x) sizeof(x)
21 #define lc(x) (x << 1)
22 #define rc(x) (x << 1 | 1)
23 #define lowbit(x) (x & (-x))
24 #define ll long long
25 #define maxn 550
26 #define maxm 500000
27 const int inf = 1 << 28;
28 int maz[maxn][maxn];
29 int dp[maxn][maxn];
30 int rr[maxn], cc[maxn], mm[maxn];
31 int office[maxn];
32 int n, m;
33 int R, C, M;
34 int ans, anscost, eh[maxn], tot, low[maxn], p[maxn], dist[maxn];
35 int S, T; //源，汇
36 struct Edge {
37     int u, v, cost, cap, flow, next;
38 } et[maxm];
39 bool visit[maxn];
40
41 bool spfa() {
42     queue<int> que;
43     memset(visit, false, sizeof (visit));
44     memset(p, -1, sizeof (p));
45     memset(low, 0, sizeof(low));
46     fill(&dist[0], &dist[maxn], inf);
47     visit[S] = true, low[S] = inf, dist[S] = 0;
48     que.push(S);
49     while (!que.empty()) {
50         int u = que.front();
51         que.pop();
52         visit[u] = false;
53         for (int i = eh[u]; i != -1; i = et[i].next) {
54             int v = et[i].v, cost = et[i].cost, cap = et[i].cap, flow = et[i].flow;
55             if (flow < cap && dist[u] + cost < dist[v]) {
56                 dist[v] = dist[u] + cost;
57                 p[v] = i; //注意，这里是 i
58                 low[v] = min(low[u], cap - flow);
59                 if (!visit[v]) {
60                     visit[v] = true;
61                     que.push(v);
62                 }
63             }
64         }
65     }
66     return dist[T] != inf;
67 }
68
69 void costflow() {
70     ans = 0, anscost = 0;
71     while (spfa()) {
72         int x = p[T];
73         ans += low[T];
74         anscost += low[T] * dist[T];
75         while (x != -1) {
76             et[x].flow += low[T];
77             et[x^1].flow -= low[T];
78             et[x^1].cost = -et[x].cost;
79             x = p[et[x].u];
80         }
81     }
82 }
83
84 void add(int u, int v, int cost, int cap, int flow) {
85     Edge e = {u, v, cost, cap, flow, eh[u]};
86     et[tot] = e;
87     eh[u] = tot++;
88 }
89
90 void addedge(int u, int v, int cost, int cap) {
91     add(u, v, cost, cap, 0), add(v, u, -cost, 0, 0);
92 }
93
94 void init() {
95     tot = 0;
96     memset(eh, -1, sizeof (eh));
97 }
98
99 void floyd() {
100     for(int k = 1; k <= n; k++)
101         for(int i = 1; i <= n; i++)
102             for(int j = 1; j <= n; j++)
103                 maz[i][j] = min(maz[i][j], maz[i][k] + maz[k][j]);
104 }
105
106 void solve() {
107     init();
108     floyd();
109     int X = R + C + 1;
110     S = 0, T = X + 1;
111     for(int i = 1; i <= R; i++) addedge(S, i, 0, 1);
112     for(int i = 1; i <= C; i++) addedge(R + i, T, 0, 1);
113     addedge(X, T, 0, R - C);
114     for(int i = 1; i <= R; i++) {
115         for(int j = 1; j <= C; j++) {
116             for(int k = 1; k <= M; k++)
117                 dp[i][j] = min(dp[i][j], maz[rr[i]][cc[j]] + maz[cc[j]][mm[k]] + maz[mm[k]][office[i]]);
118             if(dp[i][j] < inf) addedge(i, j + R, dp[i][j], 1);
119         }
120         addedge(i, X, maz[rr[i]][office[i]], 1);
121     }
122     costflow();
123     double average = 1.0 * anscost / R;
124     average = ceil(average);
125     int aver = (int)average;
126     int hh = 8 + aver / 60;
127     int mins = aver % 60;
128     printf("%02d:%02d\n", hh, mins);
129
130 }
131
132 int main() {
133     int T;
134     scanf("%d", &T);
135     while(T--) {
136         scanf("%d%d", &n, &m);
137         for(int i = 1; i <= n; i++) {
138             for(int j = 1; j <= n; j++) {
139                 maz[i][j] = inf;
140                 dp[i][j] = inf;
141             }
142             maz[i][i] = 0;
143         }
144         for(int i = 0; i < m; i++) {
145             int a, b, c;
146             scanf("%d%d%d", &a, &b, &c);
147             maz[a][b] = maz[b][a] = c;
148         }
149         scanf("%d", &R);
150         for(int i = 1; i <= R; i++) scanf("%d%d", &rr[i], &office[i]);
151         scanf("%d", &C);
152         for(int i = 1; i <= C; i++) scanf("%d", &cc[i]);
153         scanf("%d", &M);
154         for(int i = 1; i <= M; i++) scanf("%d", &mm[i]);
155         solve();
156     }
157     return 0;
158 }
159

y @ The Angry Teletubbies 2012-07-20 11:35 发表评论

hdoj 4253 Two Famous Companies - 二分 + 最小生成树

y @ The Angry Teletubbies — Tue, 17 Jul 2012 17:36:00 GMT

【题意】：给出n个点，m条边，边分为两种，一种是A公司的，一种是B公司的。边上有权值，问用n-1条边把n个点连起来的最小费用是多少，其中A公司的边刚好有k条。题目保证有解。

【题解】：很明显看到是求一颗最小生成树，不过有一个限制就是刚刚好有k条边是A公司的。想了很久不会做，看别人代码的。二分出一个最大值delta使得A公司的边加上这个值后再求MST时A公司的边有大于等于k条，然后答案就是cost of MST - k * delta。思想其实是加上一个delta值去逼近答案，最后可以求出这样的MST，如果最后求出的MST的A公司的边多于k条，一定存在与A公司等效且等价的B公司边，替换过来即可。

【代码】：

y @ The Angry Teletubbies 2012-07-18 01:36 发表评论

zoj 2364 Data Transmission - 分层图阻塞流 + 贪心初始流

y @ The Angry Teletubbies — Mon, 09 Jul 2012 13:51:00 GMT

【题意】：给出一个分层图，求其阻塞流。

【题解】：在zoj的一场月赛看到这题，于是为了这个题学了dinic，发现裸的dinic还是TLe，要加上贪心初始流才能过。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 #define pb push_back
17 #define mp make_pair
18 #define fi first
19 #define se second
20 #define sof(x) sizeof(x)
21 #define lc(x) (x << 1)
22 #define rc(x) (x << 1 | 1)
23 #define lowbit(x) (x & (-x))
24 #define ll long long
25 #define maxn 1550
26 #define maxm 1000000
27 const int inf = 1 << 30;
28 int n, m, s, t, l;
29 int eh[maxn], low[maxn], dist[maxn], pre[maxn], cur[maxn], tot, cnt[maxn];
30 pii p[maxn];
31 int in[maxn], out[maxn];
32 struct Edge {
33     int u, v, cap, flow, next;
34 }et[maxm];
35 void init() {
36     tot = 0;
37     memset(eh, -1, sizeof(eh));
38 }
39 void add(int u, int v, int cap, int flow) {
40     Edge e = {u, v, cap, flow, eh[u]};
41     et[tot] = e;
42     eh[u] = tot++;
43 }
44 void addedge(int u, int v, int cap) {
45     add(u, v, cap, 0), add(v, u, 0, 0);
46 }
47 int isap(int s, int t, int n){
48     int u, v, now, flow = 0;
49     memset(dist, 0, sizeof(dist));
50     memset(low, 0, sizeof(low));
51     memset(cnt, 0, sizeof(cnt));
52     for(u = 0 ; u <= n ; u ++) cur[u] = eh[u];
53     low[s] = inf, cnt[0] = n, u = s;
54     while(dist[s] < n) {
55         for(now = cur[u]; now != -1; now = et[now].next)
56             if(et[now].cap - et[now].flow && dist[u] == dist[ v = et[now].v ] + 1 ) break;
57         if(now != -1) {
58             cur[u] = pre[v] = now;
59             low[v] = min(et[now].cap - et[now].flow, low[u]);
60             u = v;
61             if(u == t) {
62                 for(; u != s; u = et[pre[u]].u){
63                     et[pre[u]].flow += low[t];
64                     et[pre[u]^1].flow -= low[t];
65                 }
66                 flow += low[t]; low[s] = inf;
67             }
68         } else {
69             if(--cnt[dist[u]] == 0) break;
70             dist[u] = n, cur[u] = eh[u];
71             for(now = eh[u]; now != -1; now = et[now].next)
72                 if(et[now].cap - et[now].flow && dist[u] > dist[et[now].v] + 1)
73                     dist[u] = dist[ et[now].v ] + 1;
74             cnt[dist[u]]++;
75             if(u != s) u = et[pre[u]].u;
76         }
77     }
78     return flow;
79 }
80
81 void greedy() {//贪心初始流
82     memset(in, 0, sizeof(in));
83     memset(out, 0, sizeof(out));
84     in[s] = inf;
85     sort(p + 1, p + 1 + n);
86     for(int i = 1; i <= n; i++) {
87         for(int j = eh[p[i].se]; j != -1; j = et[j].next) {
88             if(et[j].cap > 0) {
89                 int dd = min(et[j].cap, in[p[i].se] - out[p[i].se]);
90                 out[p[i].se] += dd;
91                 in[et[j].v] += dd;
92             }
93         }
94     }
95     memset(in, 0, sizeof(in));
96     in[t] = inf;
97     for(int i = n; i >= 1; i--) {
98         for(int j = eh[p[i].se]; j != -1; j = et[j].next) {
99             if(et[j].cap == 0) {
100                 int k = j ^ 1;
101                 int u = et[k].u, v = et[k].v;
102                 if(out[u] > in[u]) {
103                     int dd = min(out[u] - in[u], et[k].cap);
104                     dd = min(dd, in[v]);
105                     in[u] += dd;
106                     in[v] -= dd;
107                     et[k].flow += dd;
108                 }
109             }
110         }
111     }
112 }
113 int main() {
114     int T, u, v, w, level;
115     scanf("%d", &T);
116     while(T--) {
117         scanf("%d%d%d", &n, &m, &l);
118         init();
119         for(int i = 1; i <= n; i++) {
120             scanf("%d", &level);
121             p[i] = mp(level, i);
122             if(level == 1) s = i;
123             else if(level == l) t = i;
124         }
125         for(int i = 0; i < m; i++) {
126             scanf("%d%d%d", &u, &v, &w);
127             addedge(u, v, w);
128         }
129         greedy();
130         isap(s, t, n);
131         for(int i = 0; i < m; i++) {
132             printf("%d\n", et[i<<1].flow);
133         }
134     }
135     return 0;
136 }
137

y @ The Angry Teletubbies 2012-07-09 21:51 发表评论

zoj 3509 Island Communication - 保留最小生成森林

y @ The Angry Teletubbies — Tue, 15 May 2012 01:03:00 GMT

【题意】：有n个岛，初始没有桥，每次可以在i和j间建一座桥，拆一座桥，或查询i和j是否联通，i和j之间最多只会建一次桥。点数n=500，操作数m=50000。

【题解】：由于点数只有500，其实这题不需要任何高级的数据结构就有一个O(n*m)的算法。注意到点数很少，而要求i和j是否联通，我们只要保留这幅图的生成森林就足够了，即控制边的个数为O(n)。对于查询操作，直接dfs一次即可。对于加边操作，如果i和j不联通，那么直接加上这条边就好了。否则，加上这条边后一定形成一个圈，如果我们把这个圈中最早被删去的边提前删掉，是不会影响后面操作的结果的，所以我们删掉这条边，以保证图中始终没有圈。对于删边操作，如果这个边已经被提前删掉了，那么什么也不做，否则简单删掉就好了。要知道哪条边先被删掉，可以先读入所有操作，预处理之。对于每次操作，复杂度均为O(n)，总的复杂度O(n*m)。

【代码】：

y @ The Angry Teletubbies 2012-05-15 09:03 发表评论

hdoj 1534 Schedule Problem - 差分约束

y @ The Angry Teletubbies — Wed, 18 Apr 2012 02:28:00 GMT

【题意】：给出n个任务以及他们的运行时间t[i].其中有4种依赖关系: FAS, FAF, SAF和SAS. F—finish,S—start,A—after.给出很多组关系,
[ FAS i j ]表示i的finish要发生在j的start之后,其他关系以此类推.
求一种调度方案使时间最短并输出每个任务的开始时间.

【题解】：设s[i]为任务i的开始时间，v[i]为任务i的运行时间：
对于每种限制，都可以转化为不等式关系。
SAF a b => s[a] >= s[b] + val[b];
FAF a b => s[a] + v[a] >= s[b] + v[b];
SAS a b => s[a] >= s[b];
FAS a b => s[a] + v[a] >= s[b];

题目有一个条件是是第一个任务开始时间必须为0，还有一个隐含条件是所有任务的开始时间必须大于等于0.
构造一个差分约束系统求最长路既可得到每个任务的最短开始时间。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 #define maxn 10050
22 #define maxm 500000
23 const int inf = 1 << 29;
24 struct Edge {
25     int u, v, cost, next;
26 } et[maxm];
27
28 int eh[maxn], tot, dist[maxn], cnt[maxn];
29 bool visit[maxn];
30 int n, m;
31 int val[maxn];
32 int s;
33
34 void init() {
35     tot = 0;
36     memset(eh, -1, sizeof (eh));
37 }
38
39 void addedge(int u, int v, int cost) {
40     Edge e = {u, v, cost, eh[u]};
41     et[tot] = e;
42     eh[u] = tot++;
43 }
44
45 bool spfa(int s) {
46     for (int i = 0; i <= n; i++) visit[i] = false, dist[i] = -inf, cnt[i] = 0;
47     dist[s] = 0, visit[s] = true, cnt[s]++;
48     queue<int> que;
49     que.push(s);
50     while (!que.empty()) {
51         int u = que.front();
52         que.pop(), visit[u] = false;
53         for (int i = eh[u]; i != -1; i = et[i].next) {
54           int v = et[i].v, cost = et[i].cost;
55             if (dist[v] < cost + dist[u]) {
56                 dist[v] = cost + dist[u];
57                 if (!visit[v]) {
58                     visit[v] = true;
59                     que.push(v);
60                     cnt[v]++;
61                     if (cnt[v] >= n + 1) return false;
62                 }
63             }
64         }
65     }
66     return true;
67 }
68
69 int main() {
70     string s;
71     int Case = 1;
72     while(~scanf("%d", &n)) {
73         if(!n) break;
74         init();
75         for(int i = 1; i <= n; i++) {
76             scanf("%d", &val[i]);
77             addedge(0, i, 0);
78         }
79         addedge(1, 0, 0);
80         int a, b;
81         while(1) {
82             cin >> s;
83             if(s == "#") break;
84             scanf("%d%d", &a, &b);
85             if(s == "SAF") addedge(b, a, val[b]);
86             else if(s == "FAF") addedge(b, a, val[b] - val[a]);
87             else if(s == "SAS") addedge(b, a, 0);
88             else if(s == "FAS") addedge(b, a, -val[a]);
89         }
90         printf("Case %d:\n", Case++);
91         if(spfa(0)) {
92             for(int i = 1; i <= n; i++) {
93                 printf("%d %d\n", i, dist[i]);
94             }
95         } else printf("impossible\n");
96         printf("\n");
97     }
98     return 0;
99 }
100

y @ The Angry Teletubbies 2012-04-18 10:28 发表评论

hdoj 3987 Harry Potter and the Forbidden Forest - 最大流最小割 + 割边最少

y @ The Angry Teletubbies — Tue, 17 Apr 2012 05:35:00 GMT

【题意】：给出一幅图，求边最小的最小割。

【题解】：求两次最小割。
第一次求出所有割边。
然后把割边容量设成1，非割边容量为inf，再求一次最小割即为答案。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 using namespace std;
5 #define maxn 1000
6 #define maxm 500000
7 const int inf = 1 << 30;
8 int s, t, n, m;
9 int eh[maxn], low[maxn], dist[maxn], cnt[maxn], tot, pre[maxn], cur[maxn];
10 bool color[maxn];
11 struct Edge {
12     int u, v, cap, flow, next;
13 }et[maxm];
14
15 void init() {
16     tot = 0;
17     memset(eh, -1, sizeof(eh));
18 }
19
20 void add(int u, int v, int cap, int flow) {
21     Edge e = {u, v, cap, flow, eh[u]};
22     et[tot] = e;
23     eh[u] = tot++;
24 }
25
26 void addedge(int u, int v, int cap) {
27     add(u, v, cap, 0), add(v, u, 0, 0);
28 }
29
30 int isap(int s, int t, int n) {
31     int u, v, now, flow = 0;
32     memset(low, 0, sizeof(low));
33     memset(cnt, 0, sizeof(cnt));
34     memset(dist, 0, sizeof(dist));
35     for(u = 0; u <= n; u++) cur[u] = eh[u];
36     low[s] = inf, cnt[0] = n;
37     u = s;
38     while(dist[s] < n) {
39         for(now = cur[u]; now != -1; now = et[now].next)
40             if(et[now].cap - et[now].flow && dist[u] == dist[v = et[now].v] + 1) break;
41         if(now != -1) {
42             cur[u] = pre[v] = now;
43             low[v] = min(low[u], et[now].cap - et[now].flow);
44             u = v;
45             if(u == t) {
46                 for(; u != s; u = et[pre[u]].u) {
47                     et[pre[u]].flow += low[t];
48                     et[pre[u]^1].flow -= low[t];
49                 }
50                 low[s] = inf, flow += low[t];
51             }
52         } else {
53             if(--cnt[dist[u]] == 0) break;
54             dist[u] = n;
55             cur[u] = eh[u];
56             for(now = eh[u]; now != -1; now = et[now].next)
57                 if(et[now].cap - et[now].flow && dist[u] > dist[v = et[now].v] + 1)
58                     dist[u] = dist[v] + 1;
59             cnt[dist[u]]++;
60             if(u != s) u = et[pre[u]].u;
61         }
62     }
63     return flow;
64 }
65
66 void dfs(int u) {
67     color[u] = 1;
68     for(int i = eh[u]; i != -1; i = et[i].next)
69         if(!color[et[i].v] && et[i].cap - et[i].flow)
70             dfs(et[i].v);
71 }
72
73 int main() {
74     int T;
75     scanf("%d", &T);
76     for(int tt = 1; tt <= T; tt++) {
77         scanf("%d%d", &n, &m);
78         init();
79         s = 0, t = n - 1;
80         for(int i = 0; i < m; i++) {
81             int u, v, cap, d;
82             scanf("%d%d%d%d", &u, &v, &cap, &d);
83             if(d) addedge(u, v, cap), addedge(v, u, cap);
84             else addedge(u, v, cap);
85         }
86         isap(s, t, n);
87         for(int i = 0; i < tot; i += 2) {
88             if(et[i].cap == et[i].flow) et[i].cap = 1, et[i].flow = 0;
89             else et[i].flow = 0;
90             et[i^1].cap = et[i^1].flow = 0;
91         }
92         int ans = isap(s, t, n);
93         printf("Case %d: %d\n", tt, ans);
94     }
95 }
96

y @ The Angry Teletubbies 2012-04-17 13:35 发表评论

hdoj 4115 Eliminate the Conflict - 2-Sat

y @ The Angry Teletubbies — Tue, 17 Apr 2012 03:25:00 GMT

【题意】：Alice和Bob要玩n局剪刀石头布， Alice已知Bob在n个回合中每一回合所出的类型（Bob好悲催！OIZ）。现在对于Alice有m个限制，每个限制由a,b,k三个数字来描述。如果k等于0，则代表第a局和第b局Alice必须出的相同。如果k==1，则代表第a局和第b局Alice必须出的不同。求是否存在可以使得Alice每局必胜且符合以上m个要求的方案。

【题解】：初看像是3-sat的东西，但是3-sat是个NP问题。
仔细分析，每个回合对于Alice只有两种可能，就是平或者赢，因为Alice要保证不输，所以转化为2-sat问题。

【代码】：

1 #include "iostream"
2 #include "cstring"
3 #include "cstdio"
4 using namespace std;
5 #define MAX 10500
6 #define maxn 20500
7 #define maxm 10000000
8 int n, m;
9 int Bob[MAX], Alice[MAX][2];
10 int dfn[maxn], low[maxn], Dindex, belong[maxn], scc;
11 int s[maxn], top;
12 int eh[maxn], tot;
13 bool instack[maxn];
14 struct Edge {
15     int v, next;
16 }et[maxm];
17
18 void init() {
19     tot = 0;
20     memset(eh, -1, sizeof(eh));
21 }
22
23 void addedge(int u, int v) {
24     Edge e = {v, eh[u]};
25     et[tot] = e;
26     eh[u] = tot++;
27 }
28
29 void dfs(int u) {
30     int v;
31     dfn[u] = low[u] = ++Dindex;
32     s[++top] = u, instack[u] = true;
33     for(int i = eh[u]; i != -1; i = et[i].next) {
34         v = et[i].v;
35         if(!dfn[v]) dfs(v), low[u] = min(low[u], low[v]);
36         else if(instack[v]) low[u] = min(low[u], dfn[v]);
37     }
38     if(dfn[u] == low[u]) {
39         scc++;
40         do {
41             v = s[top--];
42             instack[v] = false;
43             belong[v] = scc;
44         } while(u != v);
45     }
46 }
47
48 void tarjan() {
49     top = scc = Dindex = 0;
50     memset(dfn, 0, sizeof(dfn));
51     memset(instack, false, sizeof(instack));
52     for(int i = 1; i <= 2 * n; i++)
53         if(!dfn[i]) dfs(i);
54 }
55
56 bool solvable() {
57     for(int i = 1; i <= n; i++)
58         if(belong[i] == belong[i+n]) return false;
59     return true;
60 }
61
62 int main() {
63     int T, Case = 1;
64     int a, b, c;
65     scanf("%d", &T);
66     while(T--) {
67         init();
68         scanf("%d%d", &n, &m);
69         for(int i = 1; i <= n; i++) {
70             scanf("%d", &Bob[i]);
71             if(Bob[i] == 1) Alice[i][0] = 1, Alice[i][1] = 2;
72             else if(Bob[i] == 2) Alice[i][0] = 2, Alice[i][1] = 3;
73             else Alice[i][0] = 3, Alice[i][1] = 1;
74         }
75         for(int i = 0; i < m; i++) {
76             scanf("%d%d%d", &a, &b, &c);
77             if(c) {
78                 if(Alice[a][0] == Alice[b][0]) addedge(a, b + n), addedge(b, a + n);
79                 else if(Alice[a][0] == Alice[b][1]) addedge(a, b), addedge(b + n, a + n);
80                 if(Alice[a][1] == Alice[b][0]) addedge(a + n, b + n), addedge(b, a);
81                 else if(Alice[a][1] == Alice[b][1]) addedge(a + n, b), addedge(b + n, a);
82             } else {
83                 if(Alice[a][0] != Alice[b][0]) addedge(a, b + n), addedge(b, a + n);
84                 if(Alice[a][0] != Alice[b][1]) addedge(a, b), addedge(b + n, a + n);
85                 if(Alice[a][1] != Alice[b][0]) addedge(a + n, b + n) , addedge(b, a);
86                 if(Alice[a][1] != Alice[b][1]) addedge(a + n, b), addedge(b + n, a);
87             }
88         }
89         tarjan();
90         printf("Case #%d: ", Case++);
91         if(solvable()) printf("yes\n");
92         else printf("no\n");
93
94     }
95     return 0;
96 }
97

y @ The Angry Teletubbies 2012-04-17 11:25 发表评论

hdoj 3691 Nubulsa Expo - 全局最小割

y @ The Angry Teletubbies — Thu, 12 Apr 2012 08:18:00 GMT

【题意】：给出一个无向图和源点，问以哪个点为汇点的最大流最小。

【题解】：朴素方法是枚举汇点，每一次跑一个最大流，但这明显会超时。
由最大流最小割定理，转化为最小割最小。
然后用Stoer-Wagner算法，直接求全局最小割即为答案，时间复杂度为O(n*n*n).

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 #define maxn 510
22 const int inf = 1 << 27;
23 int maz[maxn][maxn];
24 int n, m, s;
25 int StoerWagner(int n) {
26     int cnt = n, s, t;
27     int cut = inf;
28     bool visit[maxn], use[maxn];
29     int dist[maxn];
30     memset(use, false, sizeof(use));
31     while(--cnt > 0) {
32         memset(visit, false, sizeof(visit));
33         memset(dist, 0, sizeof(dist));
34         int u = 0;
35         while(use[u]) u++;
36         visit[u] = true;
37         for(int v = 0; v < n; v++)
38             if(!use[v] && !visit[v])
39                 dist[v] = maz[v][u];
40         s = t = u;
41         for(int i = u; i < n; i++) {
42             int max = 0, idx = u;
43             for(int j = 0; j < n; j++)
44                 if(!use[j] && !visit[j] && dist[j] > max)
45                     max = dist[idx = j];
46             if(!max) break;
47             visit[idx] = true;
48             for(int j = 0; j < n; j++)
49                 if(!use[j] && !visit[j])
50                     dist[j] += maz[j][idx];
51             s = t, t = idx;
52         }
53         cut = min(cut, dist[t]);
54         use[t] = true;
55         for(int i = 0; i < n; i++)
56             if(!use[i]) {
57                 maz[s][i] += maz[t][i];
58                 maz[i][s] += maz[i][t];
59             }
60
61     }
62     return cut;
63 }
64
65 int main() {
66     while(~scanf("%d%d%d", &n, &m, &s)) {
67         if(!n) break;
68         memset(maz, 0, sizeof(maz));
69         for(int i = 0; i < m; i++) {
70             int a, b, c;
71             scanf("%d%d%d", &a, &b, &c);
72             a--, b--;
73             maz[a][b] += c;
74             maz[b][a] += c;
75         }
76         int ans = StoerWagner(n);
77         cout << ans << endl;
78     }
79     return 0;
80 }
81

y @ The Angry Teletubbies 2012-04-12 16:18 发表评论

poj 1129 Channel Allocation - IDA星 + 图染色

y @ The Angry Teletubbies — Mon, 26 Mar 2012 09:27:00 GMT

【题意】：给出一个平面图，问最少用多少种颜色来染色能够使得图中相邻结点颜色不同。

【题解】：平面图染色，四色定理。
直接dfs即可。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 #define maxn 30
22 bool maz[maxn][maxn], visit[maxn];
23 int color[maxn];
24 int n;
25 char a, ch;
26
27 int dfs(int u, int cnt) {
28     memset(visit, false, sizeof(visit));
29     if(u == n) return true;
30     for(int i = 0; i < n; i++) {
31         if(color[i] != -1 && maz[u][i]) {
32             visit[color[i]] = true;
33         }
34     }
35     for(int i = 0; i < cnt; i++) {
36         if(!visit[i]) {
37             color[u] = i;
38             if(dfs(u+1, cnt)) return true;
39         }
40     }
41     return false;
42 }
43
44 void solve() {
45     int ans = 5;
46     for(int i = 1; i < 5; i++) {
47         memset(color, -1, sizeof(color));
48         if(dfs(0, i)) {
49             ans = i;
50             break;
51         }
52     }
53     if(ans == 1) printf("1 channel needed.\n");
54     else printf("%d channels needed.\n", ans);
55 }
56
57 int main() {
58     while(~scanf("%d", &n), n) {
59         getchar();
60         memset(maz, false, sizeof(maz));
61         for(int i = 0; i < n; i++) {
62             scanf("%c:", &a);
63             while((ch = getchar()) != 10) {
64                 maz[a-'A'][ch-'A'] = maz[ch-'A'][a-'A'] = true;
65             }
66         }
67         solve();
68     }
69     return 0;
70 }
71

y @ The Angry Teletubbies 2012-03-26 17:27 发表评论

poj 3921 Destroying the bus stations - 最小割最大流 + floyd预处理 + 拆点

y @ The Angry Teletubbies — Sun, 18 Mar 2012 14:34:00 GMT

【题意】：给出n个城市，m条边，问最少摧毁多少个城市使得城市1到城市n的最短路大于k。

【题解】：先用floyd求出点对的最短路，判断哪些点是在长度少于等于k的路上，然后把每个城市拆点，容量为1，加入原图上的边，容量为inf。
求最小割即为答案。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 #define maxn 1050
22 #define maxm 1000050
23 const int inf = 1 << 30;
24 int maz[55][55];
25 int n, m, k;
26 int s, t;
27 int eh[maxn], low[maxn], dist[maxn], pre[maxn], cur[maxn], tot, cnt[maxn];
28
29 struct Edge {
30     int u, v, cap, flow, next;
31 }et[maxm];
32
33 void init() {
34     tot = 0;
35     memset(eh, -1, sizeof(eh));
36 }
37
38 void add(int u, int v, int cap, int flow) {
39     Edge e = {u, v, cap, flow, eh[u]};
40     et[tot] = e;
41     eh[u] = tot++;
42 }
43
44 void addedge(int u, int v, int cap) {
45     add(u, v, cap, 0), add(v, u, 0, 0);
46 }
47
48 void floyd() {
49     for(int k = 1; k <= n; k++) {
50         for(int i = 1; i <= n; i++) {
51             for(int j = 1; j <= n; j++) {
52                 if(maz[i][k] != inf && maz[k][j] != inf)
53                     maz[i][j] = min(maz[i][j], maz[i][k] + maz[k][j]);
54             }
55         }
56     }
57 }
58
59 int isap(int s, int t, int n){
60     int u, v, now, flow = 0;
61     memset(dist, 0, sizeof(dist));
62     memset(low, 0, sizeof(low));
63     memset(cnt, 0, sizeof(cnt));
64     for(u = 0 ; u <= n ; u ++) cur[u] = eh[u];
65     low[s] = inf, cnt[0] = n, u = s;
66     while(dist[s] < n) {
67         for(now = cur[u]; now != -1; now = et[now].next)
68             if(et[now].cap - et[now].flow && dist[u] == dist[ v = et[now].v ] + 1 ) break;
69         if(now != -1) {
70             cur[u] = pre[v] = now;
71             low[v] = min(et[now].cap - et[now].flow, low[u]);
72             u = v;
73             if(u == t) {
74                 for(; u != s; u = et[pre[u]].u){
75                     et[pre[u]].flow += low[t];
76                     et[pre[u]^1].flow -= low[t];
77                 }
78                 flow += low[t]; low[s] = inf;
79             }
80         } else {
81             if(--cnt[dist[u]] == 0) break;
82             dist[u] = n, cur[u] = eh[u];
83             for(now = eh[u]; now != -1; now = et[now].next)
84                 if(et[now].cap - et[now].flow && dist[u] > dist[et[now].v] + 1)
85                     dist[u] = dist[ et[now].v ] + 1;
86             cnt[dist[u]]++;
87             if(u != s) u = et[pre[u]].u;
88         }
89     }
90     return flow;
91 }
92
93 int main() {
94     int u, v;
95     while(~scanf("%d%d%d", &n, &m, &k)) {
96         if(!n) break;
97         s = 1, t = n;
98         init();
99         for(int i = 0; i < 55; i++)
100             for(int j = 0; j < 55; j++)
101                 maz[i][j] = inf;
102         for(int i = 0; i < m; i++) {
103             scanf("%d%d", &u, &v);
104             maz[u][v] = 1;
105         }
106         floyd();
107         for(int i = 2; i < n; i++) {
108             if(maz[s][i] + maz[i][t] <= k) {
109                 addedge(i, i + n, 1);
110             }
111         }
112         for(int i = 1; i <= n; i++) {
113             for(int j = 1; j <= n; j++) {
114                 if(maz[i][j] == 1) addedge(i + n, j, inf);
115             }
116         }
117         int ans = isap(s + n, t, 2 * n - 2);
118         cout << ans << endl;
119     }
120     return 0;
121 }
122

y @ The Angry Teletubbies 2012-03-18 22:34 发表评论

poj 1797 Heavy Transportation - 最短路 + dp

y @ The Angry Teletubbies — Thu, 08 Mar 2012 08:46:00 GMT

【题意】：求城市1到城市n可行路径上最小值的最大值。

【题解】：最短路变形，加上一点dp思想。
把dist[]数组存储的东西改一下即可。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define lc(x) (x << 1)
15 #define rc(x) (x << 1 | 1)
16 #define lowbit(x) (x & (-x))
17 #define ll long long
18 #define maxn 1050
19 const int inf = 1 << 30;
20 int n, m;
21 int maz[maxn][maxn];
22 int dist[maxn];
23 bool visit[maxn];
24 void prim(int s) {
25     memset(visit, false, sizeof(visit));
26     memset(dist, -1, sizeof(dist));
27     dist[s] = inf;
28     while(1) {
29         int u = -1;
30         for(int i = 1; i <= n; i++)
31             if(!visit[i] && (u == -1 || dist[i] > dist[u]))
32                 u = i;
33         if(u == -1) break;
34         visit[u] = true;
35         for(int i = 1; i <= n; i++) {
36             if(!visit[i] && maz[u][i] != -1)
37                 dist[i] = max(dist[i], min(dist[u], maz[u][i]));
38         }
39     }
40 }
41
42 int main() {
43     int T, Case = 1;
44     int u, v, w;
45     scanf("%d", &T);
46     while(T--) {
47         memset(maz, -1, sizeof(maz));
48         scanf("%d%d", &n, &m);
49         for(int i = 0; i < m; i++) {
50             scanf("%d%d%d", &u, &v, &w);
51             maz[u][v] = maz[v][u] = w;
52         }
53         prim(1);
54         printf("Scenario #%d:\n%d\n\n", Case++, dist[n]);
55     }
56     return 0;
57 }
58

y @ The Angry Teletubbies 2012-03-08 16:46 发表评论

poj 2728 Desert King - 最优比率生成树 + 01分数规划 + Dinkelbach

y @ The Angry Teletubbies — Sun, 26 Feb 2012 08:49:00 GMT

【题意】：求最小比率生成树。

【题解】：最小比率生成树和01分数规划都是从这里学到的。
最小比率生成树的模型其实就是01分数规划，关于01分数规划的资料，网上一大堆。
简单说下做法，就是构造一个01分数规划的式子，然后变形，利用MST求取当前的最小值。
然后利用二分或者Dinkelbach逼近到最优解即为答案。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define lc(x) (x << 1)
15 #define rc(x) (x << 1 | 1)
16 #define lowbit(x) (x & (-x))
17 #define ll long long
18 #define maxn 1050
19 #define eps 1e-6
20
21 int n;
22 double d[maxn][maxn];
23 int cost[maxn][maxn];
24
25 struct Point {
26     double x, y;
27     int z;
28 }p[maxn];
29
30 double getdist(Point &a, Point &b) {
31     return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
32 }
33
34 int getcost(Point &a, Point &b) {
35     return abs(a.z - b.z);
36 }
37
38 double prim(int s, double &l) {
39     double anslen = 0.0, anscost = 0.0;
40     bool visit[maxn];
41     double dist[maxn], tmp, ans = 0.0;
42     int pre[maxn];
43     for(int i = 0; i < n; i++) visit[i] = false, dist[i] = 1e30;
44     dist[s] = 0.0, pre[s] = s;
45     while(1) {
46         int u = -1;
47         for(int i = 0; i < n; i++) {
48             if(!visit[i] && (u == -1 || dist[i] < dist[u])) u = i;
49         }
50         if(u == -1) break;
51         anscost += cost[pre[u]][u];
52         anslen += d[pre[u]][u];
53         ans += dist[u];
54         visit[u] = true;
55         for(int i = 0; i < n; i++) {
56             if(!visit[i] && (tmp = 1.0 * cost[u][i] - l * d[u][i]) < dist[i])
57                 dist[i] = tmp, pre[i] = u;
58         }
59     }
60     l = anscost / anslen;
61     return ans;
62 }
63
64 void solve() {
65     double ans= 0.0, tmp = 0.0;
66     while(1) {
67         double tmp = prim(0, ans);
68         if(fabs(tmp) < eps) break;
69     }
70     printf("%.3f\n", ans);
71 }
72
73 int main() {
74     while(scanf("%d", &n) && n) {
75         for(int i = 0; i < n; i++) {
76             scanf("%lf%lf%d", &p[i].x, &p[i].y, &p[i].z);
77             for(int j = 0; j < i; j++) {
78                 d[i][j] = d[j][i] = getdist(p[i], p[j]);
79                 cost[i][j] = cost[j][i] = getcost(p[i], p[j]);
80             }
81         }
82         solve();
83     }
84     return 0;
85 }
86

y @ The Angry Teletubbies 2012-02-26 16:49 发表评论

hdoj 4160 Dolls - 图的最小路径覆盖 + 二分图匹配

y @ The Angry Teletubbies — Sat, 18 Feb 2012 15:05:00 GMT

【题意】：给出n个箱子，每个箱子有三个值w,l,h。如果一个箱子的这三个值严格小于另一个箱子的三个值，那么可以把这个箱子放在另一个箱子里面。每个箱子里面最多只能放一个箱子，问最小情况下还有多少个箱子。

【题解】：一开始直接上排序加贪心，然后发现有明显的bug。
考虑排序后dp，发现是个2d的最长上升子序列，不过难以实现。
无奈之下请教3x，原来是个经典问题，最小路径覆盖。
最小路径覆盖在二分图上满足：最小路径覆盖 = 顶点数 - 最大匹配。
由于原图不是二分图，需实行转换，只需拆点即可。
最后直接上匈牙利即可。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define lc(x) (x << 1)
15 #define rc(x) (x << 1 | 1)
16 #define lowbit(x) (x & (-x))
17 #define ll long long
18 #define maxn 1500
19 #define maxm 1000500
20 int n;
21 int eh[maxn], tot;
22 bool visit[maxn];
23 int match[maxn];
24
25 struct Edge {
26     int u, v, next;
27 }et[maxm];
28
29 struct Point {
30     int w, l, h;
31 }p[maxn];
32
33 void init() {
34     tot = 0;
35     memset(eh, -1, sizeof(eh));
36 }
37
38 void addedge(int u, int v) {
39     Edge e = {u, v, eh[u]};
40     et[tot] = e;
41     eh[u] = tot++;
42 }
43
44 bool dfs(int u) {
45     for(int i = eh[u]; i != -1; i = et[i].next) {
46         int v = et[i].v;
47         if (!visit[v]) {
48             visit[v] = true;
49             if (match[v] == -1 || dfs(match[v])) {
50                 match[v] = u;
51                 return true;
52             }
53         }
54     }
55     return false;
56 }
57
58 int Match() {//二分图匹配
59     int cnt = 0;
60     memset(match, -1, sizeof (match));
61     for (int u = 1; u <= 2 * n; u++) {
62         memset(visit, false, sizeof (visit));
63         if (dfs(u)) cnt++; //每找到一条增广路，匹配数+1
64     }
65     return cnt; //返回最大匹配数
66 }
67
68 bool check(const Point &a, const Point &b) {
69     return a.h < b.h && a.l < b.l && a.w < b.w;
70 }
71
72 void build() {
73     init();
74     for(int i = 0; i < n; i++) {
75         for(int j = 0; j < n; j++) {
76             if(check(p[i], p[j])) addedge(i + n, j);
77         }
78     }
79 }
80
81 int main() {
82     while(~scanf("%d", &n) && n) {
83         for(int i = 0; i < n; i++) scanf("%d%d%d", &p[i].w, &p[i].l, &p[i].h);
84         build();
85         printf("%d\n", n - Match());
86     }
87     return 0;
88 }

y @ The Angry Teletubbies 2012-02-18 23:05 发表评论

poj 1330 Nearest Common Ancestors - LCA + Tarjan算法

y @ The Angry Teletubbies — Fri, 27 Jan 2012 08:35:00 GMT

【题意】：求一棵树上的最近公共祖先。

【题解】：模板题。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 using namespace std;
11 #define pb push_back
12 #define lc(x) (x << 1)
13 #define rc(x) (x << 1 | 1)
14 #define lowbit(x) (x & (-x))
15 #define ll long long
16 #define maxn 10005
17 vector<int> tree[maxn], Q[maxn];
18 int in[maxn], n;
19 bool visit[maxn];
20 int fa[maxn];
21
22 void init() {
23     for(int i = 0; i <= n; i++) fa[i] = i, tree[i].clear(), Q[i].clear();
24     memset(visit, false, sizeof(visit));
25     memset(in, 0, sizeof(in));
26 }
27
28 int find(int x) {
29     if(x == fa[x]) return x;
30     else return fa[x] = find(fa[x]);
31 }
32
33 bool un(int a, int b) {
34     a = find(a), b = find(b);
35     if(a == b) return false;
36     fa[b] = a;
37     return true;
38 }
39
40 void Tarjan(int u) {
41     int size = tree[u].size();
42     for(int i = 0; i < size; i++) {
43         Tarjan(tree[u][i]);
44         un(u, tree[u][i]);
45     }
46     visit[u] = true, size = Q[u].size();
47     for(int i = 0; i < size; i++) {
48         if(visit[Q[u][i]]) {
49             printf("%d\n", find(Q[u][i]));
50             return;
51         }
52     }
53 }
54
55 int main() {
56     int T, u, v;
57     scanf("%d", &T);
58     while(T--) {
59         scanf("%d", &n);
60         init();
61         for(int i = 0; i < n - 1; i++) {
62             scanf("%d%d", &u, &v);
63             tree[u].pb(v);
64             in[v]++;
65         }
66         scanf("%d%d", &u, &v);
67         Q[u].pb(v), Q[v].pb(u);
68         int root = -1;
69         for(int i = 1; i <= n; i++) {
70             if(in[i] == 0) {
71                 root = i;
72                 break;
73             }
74         }
75         Tarjan(root);
76     }
77     return 0;
78 }
79

y @ The Angry Teletubbies 2012-01-27 16:35 发表评论

poj 1679 The Unique MST - 次小生成树

y @ The Angry Teletubbies — Thu, 26 Jan 2012 08:16:00 GMT

【题意】：问图中的最小生成树是否唯一。

【题解】：先求出最小生成树，再求次小生成树，如果最小生成树 == 次小生成树，则不唯一；否则，唯一。纯粹模板题。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 using namespace std;
11 #define pb push_back
12 #define lc(x) (x << 1)
13 #define rc(x) (x << 1 | 1)
14 #define lowbit(x) (x & (-x))
15 #define ll long long
16 const int inf = 1 << 30;
17 #define maxn 150
18 int maz[maxn][maxn], path[maxn][maxn];
19 bool visit[maxn];
20 int dist[maxn], pre[maxn], stack[maxn];
21 int n, m;
22
23 void init() {
24     for (int i = 1; i <= n; i++)
25         for (int j = 1; j <= n; j++)
26             maz[i][j] = inf, path[i][j] = 0;
27 }
28
29 int Prim(int s) {
30     for (int i = 1; i <= n; i++) dist[i] = maz[s][i], visit[i] = 0, pre[i] = s;
31     int top = 0, sum = 0;
32     visit[s] = true, dist[s] = 0, stack[top++] = s;
33     while (1) {
34         int u = -1;
35         for (int i = 1; i <= n; i++)
36             if (!visit[i] && (u == -1 || dist[u] > dist[i]))
37                 u = i;
38         if (u == -1) break;
39         sum += dist[u], stack[top++] = u, visit[u] = true;
40         for (int i = 0; i < top; i++) {
41             if (stack[i] == u) continue;
42             path[stack[i]][u] = max(path[pre[u]][stack[i]], dist[u]);
43             path[u][stack[i]] = path[stack[i]][u];
44         }
45         for (int i = 1; i <= n; i++)
46             if (!visit[i] && (maz[u][i] < dist[i]))
47                 dist[i] = maz[u][i], pre[i] = u;
48     }
49     return sum;
50 }
51
52 void SMT() {//次小生成树
53     int Min = inf, sum = Prim(1);//先求一次最小生成树
54     for (int i = 1; i < n; i++)
55         for (int j = i + 1; j <= n; j++)
56             if (pre[i] != j && pre[j] != i && maz[i][j] < inf)
57                 Min = min(Min, sum - path[i][j] + maz[i][j]);
58     if (Min == sum) puts("Not Unique!");
59     else printf("%d\n", sum);
60 }
61
62 int main() {
63     int T, u, v, w;
64     scanf("%d", &T);
65     while(T--) {
66         scanf("%d%d", &n, &m);
67         init();
68         for(int i = 0; i < m; i++) {
69             scanf("%d%d%d", &u, &v, &w);
70             maz[u][v] = maz[v][u] = w;
71         }
72         SMT();
73     }
74     return 0;
75 }

y @ The Angry Teletubbies 2012-01-26 16:16 发表评论

hdoj 4081 Qin Shi Huang's National Road System - 次小生成树变形

y @ The Angry Teletubbies — Thu, 26 Jan 2012 08:05:00 GMT

【题意】：给出n(n<=1000)个城市的坐标和城市的居住人口，要求修n-1条路使得n个城市连通，修路的代价就是路长，并且允许免费修一条路。问：被免费的路所连接的两个城市人口之和比上修路的代价（这里是n-2条路的代价之和，因为有一条路是免费的)的最大值是多少。

【题解】：这题是北京现场赛的A题，当时想到解法，可惜是O(n*n*n)的。
其实这题就是一道次小生成树变形，不过当时不会，现在学了，顺便切了它。
首先可以想到最小生成树，但是免费的路这个怎么处理，考虑到数据n<=1000，我们可以枚举两点之间的路。
如果该路已经在MST上，那么比值就是(cnt[u]+cnt[v]) / (MST - w(u, v))；
如果该路不在MST上，那么我们把这条路加上去的话肯定会形成一个环，为了保证比值最大，我们显然要删除环上第二大的边(第一大的边肯定是新添加的这条路，不能删除)，那么比值就是(cnt[u]+cnt[v]) / (MST - path[u][v]),其中path[i][j]表示在MST上节点i到节点j路径上的最大边。
复杂度O(n*n)。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 using namespace std;
11 #define pb push_back
12 #define lc(x) (x << 1)
13 #define rc(x) (x << 1 | 1)
14 #define lowbit(x) (x & (-x))
15 #define ll long long
16 #define maxn 1005
17 const double dinf = 1e10;
18 const int inf = 1 << 30;
19 int n, m;
20 int pre[maxn], stack[2*maxn], top;
21 double maz[maxn][maxn], dist[maxn], path[maxn][maxn];
22 bool visit[maxn];
23 struct Point {
24     double x, y;
25     int cnt;
26 }p[maxn];
27
28 double getdist(const Point &a, const Point &b) {
29     return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
30 }
31
32 double prim(int s) {
33     double ans = 0;
34     for(int i = 0; i < n; i++) visit[i] = false, dist[i] = dinf, pre[i] = s;
35     dist[s] = 0, top = 0;
36     while(1) {
37         int u = -1;
38         for(int i = 0; i < n; i++) {
39             if(!visit[i] && (u == -1 || dist[i] < dist[u])) u = i;
40         }
41         if(u == -1) break;
42         stack[top++] = u, visit[u] = true;
43         ans += dist[u];
44         for(int i = 0; i < top; i++) {
45             if(stack[i] == u) continue;
46             path[stack[i]][u] = max(path[stack[i]][pre[u]], dist[u]);
47             path[u][stack[i]] = path[stack[i]][u];
48         }
49         for(int i = 0; i < n; i++) {
50             if(!visit[i] && maz[u][i] < dist[i])
51                 dist[i] = maz[u][i], pre[i] = u;
52         }
53     }
54     return ans;
55 }
56
57 void solve() {
58     double MST = prim(0), ans = 0.0;
59     for(int i = 0; i < n; i++) {
60         for(int j = 0; j < n; j++) {
61             if(i == j) continue;
62             if((pre[i] == j || pre[j] == i)) ans = max(ans, (p[i].cnt + p[j].cnt) / (MST - maz[i][j]));
63             else ans = max(ans, (p[i].cnt + p[j].cnt) / (MST - path[i][j]));
64         }
65     }
66     printf("%.2f\n", ans);
67 }
68
69 int main() {
70     int T;
71     scanf("%d", &T);
72     while(T--) {
73         scanf("%d", &n);
74         for(int i = 0; i < n; i++) {
75             scanf("%lf%lf%d", &p[i].x, &p[i].y, &p[i].cnt);
76         }
77         for(int i = 0; i < n; i++) {
78             for(int j = 0; j < n; j++) {
79                 maz[i][j] = getdist(p[i], p[j]);
80                 path[i][j] = 0.0;
81             }
82         }
83         solve();
84     }
85     return 0;
86 }

y @ The Angry Teletubbies 2012-01-26 16:05 发表评论

USTC 1280 Finding Shortest Path - 最短路 + 最小割最大流

y @ The Angry Teletubbies — Wed, 25 Jan 2012 07:29:00 GMT

【题意】：给出一幅无向图，n个顶点m条边，每条边都有一定的长度和删除这条边的代价，给出s和t，问至少用多少代价删除一些边使得s到t的最短路变长。

【题解】：显然，我们要删的边必定是最短路上的边。所以先求一次最短路，并保留最短路上的边，若满足dist[u] + w(u,v) == dist[v]，那么这条边就是最短路上的边。现在问题就转化为用最小的代价把s和t分割，这显然是个最小割的问题，求最大流即为ans。

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 using namespace std;
11 #define pb push_back
12 #define lc(x) (x << 1)
13 #define rc(x) (x << 1 | 1)
14 #define lowbit(x) (x & (-x))
15 #define ll long long
16 #define maxn 2000
17 #define maxm 50000
18 const int inf = 1 << 30;
19 int s, t, n, m;
20 struct Edge {
21     int u, v, w, cost, next;
22 }et[maxm];
23
24 struct edge {
25     int u, v, cap, flow, next;
26 }et2[maxm];
27
28 int eh[maxn], tot, dist[maxn];
29 bool visit[maxn];
30 int eh2[maxn], tot2, low[maxn], dist2[maxn], pre[maxn], cur[maxn], cnt[maxn];
31
32 void init() {
33     tot = 0;
34     tot2 = 0;
35     memset(eh, -1, sizeof (eh));
36     memset(eh2, -1, sizeof (eh2));
37 }
38
39 void addedge(int u, int v, int w, int cost) {
40     Edge e = {u, v, w, cost, eh[u]};
41     et[tot] = e;
42     eh[u] = tot++;
43 }
44
45 void add(int u, int v, int cap, int flow) {
46     edge e = {u, v, cap, flow, eh2[u]};
47     et2[tot2] = e;
48     eh2[u] = tot2++;
49 }
50
51 void addedge2(int u, int v, int cap) {
52     add(u, v, cap, 0), add(v, u, 0, 0);
53 }
54
55 void spfa(int s) {
56     for (int i = 0; i <= n; i++) visit[i] = false, dist[i] = inf, cnt[i] = 0;//dist[i] = -inf;
57     dist[s] = 0, visit[s] = true;
58     queue<int> que;
59     que.push(s);
60     while (!que.empty()) {
61         int u = que.front();
62         que.pop(), visit[u] = false;
63         for (int i = eh[u]; i != -1; i = et[i].next) {
64           int v = et[i].v, w = et[i].w;
65             if (dist[v] > w + dist[u]) {//dist[v] < w + dist[u]
66                 dist[v] = w + dist[u];
67                 if (!visit[v]) {
68                     visit[v] = true;
69                     que.push(v);
70                 }
71             }
72         }
73     }
74 }
75
76 void build() {
77     for(int i = 0; i < tot; i++) {
78         int u = et[i].u, v = et[i].v, w = et[i].w, cost = et[i].cost;
79         if(dist[u] + w == dist[v]) {
80             addedge2(u, v, cost);
81         }
82     }
83 }
84
85 int isap(int s, int t, int n){
86     int u, v, now, flow = 0;
87     memset(dist2, 0, sizeof(dist2));
88     memset(low, 0, sizeof(low));
89     memset(cnt, 0, sizeof(cnt));
90     for(u = 0 ; u <= n ; u++) cur[u] = eh2[u];
91     low[s] = inf, cnt[0] = n, u = s;
92     while(dist2[s] < n) {
93         for(now = cur[u]; now != -1; now = et2[now].next)
94             if(et2[now].cap - et2[now].flow && dist2[u] == dist2[ v = et2[now].v ] + 1 ) break;
95         if(now != -1) {
96             cur[u] = pre[v] = now;
97             low[v] = min(et2[now].cap - et2[now].flow, low[u]);
98             u = v;
99             if(u == t) {
100                 for(; u != s; u = et2[pre[u]].u){
101                     et2[pre[u]].flow += low[t];
102                     et2[pre[u]^1].flow -= low[t];
103                 }
104                 flow += low[t]; low[s] = inf;
105             }
106         } else {
107             if(--cnt[dist2[u]] == 0) break;
108             dist2[u] = n, cur[u] = eh2[u];
109             for(now = eh2[u]; now != -1; now = et2[now].next)
110                 if(et2[now].cap - et2[now].flow && dist2[u] > dist2[et2[now].v] + 1)
111                     dist2[u] = dist2[et2[now].v] + 1;
112             cnt[dist2[u]]++;
113             if(u != s) u = et2[pre[u]].u;
114         }
115     }
116     return flow;
117 }
118
119 int main() {
120     int u, v, w, c;
121     int Case = 1;
122     while(~scanf("%d%d", &n, &m)) {
123         if(!n && !m) break;
124         scanf("%d%d", &s, &t);
125         init();
126         for(int i = 0; i < m; i++) {
127             scanf("%d%d%d%d", &u, &v, &w, &c);
128             addedge(u, v, w, c);
129             addedge(v, u, w, c);
130         }
131         spfa(s);
132         build();
133         int ans = isap(s, t, n);
134         printf("Case %d: %d\n", Case++, ans);
135     }
136     return 0;
137 }
138

y @ The Angry Teletubbies 2012-01-25 15:29 发表评论

hdoj 4106 Fruit Ninja - 最大费用流

y @ The Angry Teletubbies — Wed, 09 Nov 2011 14:09:00 GMT

【题意】：切水果游戏。给出n个水果，每个水果有对应的分数，规定连续m个水果之间最多能切掉k个，求能够切得的最大分数。

【题解】：一道论文题。发现网络流确实强大，可以解决很多问题。
               这题解法是最大费用流，看到了论文的构图，发现超级强大。
               构图：
               把每个水果拆成两个点 i 和 i’，连边 i -> i’，容量为1，费用为切掉这个水果的分数；
               加入一个源点s，连边s -> i，容量为inf，费用为0；
               加入一个汇点t，连边 i’ -> t，容量为inf，费用为0；
               连边i -> i + 1，容量为inf，费用为0；
               连边i' -> i + m，容量为inf，费用为0。

               最后，限定最多增广k次即可，最大费用即为答案。这题时限卡得比较紧，最好不要用stl的queue。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 using namespace std;
5 #define maxn 2500
6 #define maxm 1000000
7 const int inf = 1 << 30;
8 int eh[maxn], p[maxn], low[maxn], tot, dist[maxn];
9 int s, t, n, m, k;
10 int ans, anscost;
11 int val[maxn];
12 bool visit[maxn];
13 int que[1000000], head, tail;
14 struct Edge {
15     int u, v, cost, cap, flow, next;
16 }et[maxm];
17
18 void init() {
19     tot = 0;
20     memset(eh, -1, sizeof(eh));
21 }
22
23 void add(int u, int v, int cost, int cap, int flow) {
24     Edge e = {u, v, cost, cap, flow, eh[u]};
25     et[tot] = e;
26     eh[u] = tot++;
27 }
28
29 void addedge(int u, int v, int cost, int cap) {
30     add(u, v, cost, cap, 0), add(v, u, -cost, 0, 0);
31 }
32
33 bool spfa() {
34     head = tail = 0;
35     memset(visit, false, sizeof(visit));
36     memset(p, -1, sizeof(p));
37     memset(low, 0, sizeof(low));
38     for(int i = 0; i < maxn; i++) dist[i] = -inf;
39     visit[s] = true, low[s] = inf, dist[s] = 0;
40     que[tail++] = s;
41     while(head < tail) {
42         int u = que[head++];
43         visit[u] = false;
44         for(int i = eh[u]; i != -1; i = et[i].next) {
45             int v = et[i].v, cost = et[i].cost, cap = et[i].cap, flow = et[i].flow;
46             if(cap - flow && dist[u] + cost > dist[v]) {
47                 dist[v] = dist[u] + cost;
48                 p[v] = i;
49                 low[v] = min(low[u], cap - flow);
50                 if(!visit[v]) {
51                     que[tail++] = v;
52                     visit[v] = true;
53                 }
54             }
55         }
56     }
57     return dist[t] != -inf;
58 }
59
60 void costflow() {
61     ans = anscost = 0;
62     while(ans < k && spfa()) {
63         int x = p[t];
64         ans += low[t];
65         anscost += low[t] * dist[t];
66         while(x != -1) {
67             et[x].flow += low[t];
68             et[x^1].flow -= low[t];
69             x = p[et[x].u];
70         }
71     }
72 }
73
74 int main() {
75     while(~scanf("%d%d%d", &n, &m, &k)) {
76         init();
77         m = min(n, m);
78         int sum = 0;
79         s = 0, t = 2 * n + 1;
80         for(int i = 1; i <= n; i++) {
81             scanf("%d", &val[i]);
82             sum += val[i];
83             addedge(s, i, 0, inf);
84             addedge(i, i + n, val[i], 1);
85             addedge(i + n, t, 0, inf);
86             if(i + 1 <= n) addedge(i, i + 1, 0, inf);
87             if(i + m <= n) addedge(i + n, i + m, 0, inf);
88         }
89         if(m == k) {
90             printf("%d\n", sum);
91             continue;
92         }
93         costflow();
94         printf("%d\n", anscost);
95     }
96     return 0;
97 }

y @ The Angry Teletubbies 2011-11-09 22:09 发表评论

网络流总结 - Flow - y

y @ The Angry Teletubbies — Wed, 19 Oct 2011 15:11:00 GMT

常见转化：
拆点(点容量转化为边容量) ：把点 i 拆点成 i , i'，连边 i -> i'，容量为点权。
拆边(无向图转化为有向图) ：对于每条无向边(u,v)拆成两条,容量均为原边权。
最小费用：最小割或者最小费用流。

最大流最小割定理：一个网络的最大流等于最小割的容量。
最小费用流定理：一个费用流是最小费用流的充要条件是这个费用流的残量网络没有负费用圈。

割的性质：

性质1（不连通）在给定的流网络中，去掉割的边集，则不存在任何一条从源到汇的路径。

性质2（两类点）在给定的流网络中，任意一个割将点集划分成两部分。割为两部分点之间的“桥梁”。

技巧：

技巧1 用正无限容量排除不参与决策的边。

技巧2 使用割的定义式来分析最优性

技巧3 利用与源或汇关联的边容量处理点权

【最大权闭合图】

定义：一个有向图的闭合图G=(V,E)是该有向图的一个点集，且该点集的所有出边都还指向该点集。即闭合图内的任意点的任意后继也一定在闭合图中。闭合图是允许超过一个连通块的。给每个点v分配一个点权（任意实数，可正可负）。最大权闭合图，是一个点权之和最大的闭合图。

构图：在原图点集的基础上增加源s和汇t；将原图每条有向边替换为容量为inf的有向边；增加连接源s到原图每个正权点u(W_u>0)的有向边，容量为W_u；增加连接原图每个负权点v(W_v<0)到汇t的有向边，容量为-W_v。

最大权闭合图 = 所有正权点的权值和 - 最小割。

【最小点权覆盖集】

定义：点覆盖集是无向图的一个点集，使得该图中所有边都至少有一个端点在该集合内。最小点覆盖集是在无向图中，点数最少的点覆盖集。
最小点权覆盖集是在带点权无向图中，点权之和最小的点覆盖集。

构图：在原图点集的基础上增加源s和汇t；将每条二分图的边替换为容量为inf的有向边；增加源s到X部的点u的有向边，容量为该点权值W_u；增加Y部的点到汇t的有向边，容量为该点权值W_v。

最小点权覆盖集 = 最小割。

【最大点劝独立集】

定义：点覆盖集是无向图的一个点集，使得任两个在该集合中的点在原图中都不相邻。最大点独立集是在无向图中，点数最多的点独立集。最大点权独立集是在带点权无向图中，点权之和最大的点独立集。

构图：同最小点权覆盖集构图。

最大点权独立集 = 总点权和 - 最小点权覆盖集。

【有上下界的网络流问题】

【无源汇最大流】：

上界用ci表示，下界用bi表示。

下界是必须流满的，那么对于每一条边，去掉下界后，其自由流为ci – bi。

主要思想：每一个点流进来的流=流出去的流

对于每一个点i，令Mi = sum(i点所有流进来的下界流) – sum(i点所有流出去的下界流)

如果Mi大于0，代表此点必须还要流出去Mi的自由流，那么我们从源点连一条Mi的边到该点。

如果Mi小于0，代表此点必须还要流进来Mi的自由流，那么我们从该点连一条Mi的边到汇点。

如果求S->T的最大流，看是否满流(S的相邻边都流满)。

满流则有解，否则无解。

【有源汇最大流】：

满足所有下界的情况下，判断是否存在可行流，方法可以转化无源汇上下界判断方法。

只要连一条T → S的边，流量为无穷，没有下界，那么原图就得到一个无源汇的循环流图。接下来的事情一样：原图中的边的流量设成自由流量ci – bi。新建源点SS汇点TT，求Mi，连边。然后求SS → TT最大流，判是否满流。

判定有解之后然后求最大流，信息都在上面求得的残留网络里面。满足所有下界时，从s → t的流量为多少？后悔边s → t的边权！然后在残留网络中s → t可能还有些自由流没有流满，再做一次s → t的最大流，所得到的最大流就是原问题的最大流(内含两部分：残留的自由流所得到的流+后悔边s → t)。

【有源汇最小流】：

先不加t → s边权为无穷的边，求SS → TT的最大流，如果还没有流满则再加t → s边权为无穷的边，再求一次最大流得到后悔边s → t就是原问题的最小流了。

y @ The Angry Teletubbies 2011-10-19 23:11 发表评论

hdoj 4049 Tourism Planning - 最大流最小割 + 最大权闭合图

y @ The Angry Teletubbies — Wed, 19 Oct 2011 08:24:00 GMT

【题意】：有n个人按照从1到m的顺序访问m个地方，每个人都可以不去或中途退出，但是如果退出了就不能再去后面的地方了。每个人去每个地方都有对应的收益和花费，n个人里任意两个人一起去同一个地方会有额外收益，如果多个人一起则额外收益为对任意两人的额外收益求和。现在求这n个人访问m个地方的收益+额外额外收益-花费的最大值。

【题解】：构图：首先对于m个地方，每个拆成n个点，这样n×m个点分别表示每个人访问每个地方，每个点的权就是这个人去对应地方的收益-花费，然后点权为正的连源，负的连汇，对于从2到m的点，每个点向它前一个点连一条容量无穷的边，表示访问该点前要先访问它前一个点。然后对于人和人间的额外收益，把每两个人间的边作为一个点，与源相连，容量为额外收益大小，然后如果这个点代表了a和b一起访问c点，则从这个点向表示a访问c和b访问c的两个点连容量为无穷的边。

【代码】：

  1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 using namespace std;
  5 const int inf = 1 << 30;
  6 #define maxn 2000
  7 #define maxm 20000
  8 int n, m, s, t;
  9 int eh[maxn], pre[maxn], low[maxn], cur[maxn], cnt[maxn], dist[maxn], tot;
10 int cost[15], ins[15][15], bonus[15][15], sum;
11 struct Edge {
12     int u, v, cap, flow, next;
13 }et[maxm];
14
15 void init() {
16     tot = sum = 0;
17     memset(eh, -1, sizeof(eh));
18 }
19
20 void add(int u, int v, int cap, int flow) {
21     Edge e = {u, v, cap, flow, eh[u]};
22     et[tot] = e;
23     eh[u] = tot++;
24 }
25
26 void addedge(int u, int v, int cap) {
27     add(u, v, cap, 0), add(v, u, 0, 0);
28 }
29
30 int isap(int s, int t, int n) {
31     int u, v, now, flow = 0;
32     memset(cnt, 0, sizeof(cnt));
33     memset(low, 0, sizeof(low));
34     memset(dist, 0, sizeof(dist));
35     for(u = 0; u <= n; u++) cur[u] = eh[u];
36     u = s, low[s] = inf, cnt[0] = n;
37     while(dist[s] < n) {
38         for(now = cur[u]; now != -1; now = et[now].next)
39             if(et[now].cap - et[now].flow && dist[u] == dist[v = et[now].v] + 1) break;
40         if(now != -1) {
41             cur[u] = pre[v] = now;
42             low[v] = min(low[u], et[now].cap - et[now].flow);
43             u = v;
44             if(u == t) {
45                 for(flow += low[t]; u != s; u = et[pre[u]].u) {
46                     et[pre[u]].flow += low[t];
47                     et[pre[u]^1].flow -= low[t];
48                 }
49             }
50         } else {
51             if(--cnt[dist[u]] == 0) break;
52             dist[u] = n, cur[u] = eh[u];
53             for(now = eh[u]; now != -1; now = et[now].next)
54                 if(et[now].cap - et[now].flow && dist[u] > dist[et[now].v] + 1)
55                     dist[u] = dist[et[now].v] + 1;
56             cnt[dist[u]]++;
57             if(u != s) u = et[pre[u]].u;
58         }
59     }
60     return flow;
61 }
62
63 void build() {
64     s = 0, t = n * m + n * n * m + 1;
65     for(int i = 1; i <= n; i++) {
66         for(int j = 1; j <= m; j++) {
67             if(ins[i][j] > 0) {
68                 addedge(s, (i - 1) * m + j, ins[i][j]);
69                 sum += ins[i][j];
70             } else addedge((i - 1) * m + j, t, -ins[i][j]);
71             if(j > 1) addedge((i - 1) * m + j, (i - 1) * m + j - 1, inf);
72         }
73     }
74     for(int i = 1; i <= n; i++) {
75         for(int j = i + 1; j <= n; j++) {
76             for(int k = 1; k <= m; k++) {
77                 addedge(s, n * m + ((i - 1) * n + j - 1) * m + k, bonus[i][j]);
78                 addedge(n * m + ((i - 1) * n + j - 1) * m + k, (i - 1) * m + k, inf);
79                 addedge(n * m + ((i - 1) * n + j - 1) * m + k, (j - 1) * m + k, inf);
80                 sum += bonus[i][j];
81             }
82         }
83     }
84 }
85
86 int main() {
87     while(~scanf("%d%d", &n, &m)) {
88         if(!n && !m) break;
89         init();
90         for(int i = 1; i <= m; i++) scanf("%d", &cost[i]);
91         for(int i = 1; i <= n; i++) {
92             for(int j = 1; j <= m; j++) {
93                 scanf("%d", &ins[i][j]);
94                 ins[i][j] -= cost[j];
95             }
96         }
97         for(int i = 1; i <= n; i++)
98             for(int j = 1; j <= n; j++)
99                 scanf("%d", &bonus[i][j]);
100         build();
101         int res = isap(s, t, t - s + 1);
102         if(res == sum) printf("STAY HOME\n");
103         else printf("%d\n", sum - res);
104     }
105     return 0;
106 }

y @ The Angry Teletubbies 2011-10-19 16:24 发表评论

poj 1201 Intervals - 差分约束系统

y @ The Angry Teletubbies — Mon, 17 Oct 2011 12:02:00 GMT

【题意】：给出一个数集合Z与n个区间,每个区间表示为[ai,bi,ci].[ai,bi,ci]表示闭区间[ai,bi]与Z至少有ci个相同的数，求出数集Z可能的最少元素个数。

【题解】：从题目中，我们可以抽象出一大堆约束条件，并且ci的定义上明显包含着不等关系。于是可以利用差分约束模型来解决。
             •(1) [ai,bi,ci]中,ai和bi最小可以取到0,为了方便，把所有的ai,bi都+1.
             •(2) 定义d[i]为闭区间[1,i]中与集合Z中共同元素的个数.要求Z的元素个数最少,就是要求d[max{bi}]-d[0]最小.
             •(3) 分析不等关系：
                  对于[ai,bi,ci],有d[bi]-d[ai-1] >= ci
                  对于每个i,有1 >= d[i]-d[i-1] >= 0

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "queue"
5 using namespace std;
6 const int inf = 1 << 30;
7 #define maxn 50500
8 #define maxm 500000
9 int n, m, l, r;
10 int eh[maxn], tot, dist[maxn];
11 bool visit[maxn];
12 struct Edge {
13     int u, v, w, next;
14 }et[maxm];
15
16 void init() {
17     tot = 0;
18     memset(eh, -1, sizeof(eh));
19 }
20
21 void addedge(int u, int v, int w) {
22     Edge e = {u, v, w, eh[u]};
23     et[tot] = e;
24     eh[u] = tot++;
25 }
26
27 void spfa(int s) {
28     queue<int> que;
29     fill(&dist[0], &dist[maxn], -inf);
30     memset(visit, false, sizeof(visit));
31     dist[s] = 0, visit[s] = true;
32     que.push(s);
33     while(!que.empty()) {
34         int u = que.front();
35         que.pop();
36         visit[u] = false;
37         for(int i = eh[u]; i !=- 1; i = et[i].next) {
38             int v = et[i].v, w = et[i].w;
39             if(dist[v] < dist[u] + w) {
40                 dist[v] = dist[u] + w;
41                 if(!visit[v]) {
42                     que.push(v);
43                     visit[v] = true;
44                 }
45             }
46         }
47     }
48 }
49
50 int main() {
51     int a, b, c;
52     while(~scanf("%d", &n)) {
53         init();
54         r = 0;
55     //    l = inf;
56         for(int i = 0; i < n; i++) {
57             scanf("%d%d%d", &a, &b, &c);
58             r = max(r, ++b);
59     //        l = min(l, a);
60             addedge(a, b, c);
61         }
62         for(int i = 1; i <= r; i++) {
63             addedge(i - 1, i, 0);
64             addedge(i, i - 1, -1);
65         }
66         spfa(0);
67         printf("%d\n", dist[r]);
68     }
69     return 0;
70 }

y @ The Angry Teletubbies 2011-10-17 20:02 发表评论

hdoj 3666 THE MATRIX PROBLEM - 差分约束系统 + dfs版spfa

y @ The Angry Teletubbies — Mon, 17 Oct 2011 08:48:00 GMT

【题意】：给出一个N*M的矩阵C，C中每个元素都是正整数且不超过1000.问是否存在一个长度为N的序列a1，a2，……，a_N和一个长度为M的序列b1，b2，……，b_M使得矩阵C中的每一个元素C_ij满足 L <= C_ij * a_i / b_j<= U。

【题解】：从题目中可以抽离出N * M个不等式，然后题目又要我们判断可行解，这样子很容易就想到差分约束系统。对于这个不等式，我们需要做点转化，用一个log化简一下即可。
                        L <= C_ij * a_i / b_j<= U       =>     log L - log C_ij<= log a_i - log b_j <= log U - log C_ij.
              然后构图找判负环即可，但是这个N*M高达800，所以queue的spfa会TLE，这里采用stack的spfa。

【代码】：

1 #include "iostream"
2 #include "cstring"
3 #include "cstdio"
4 #include "cmath"
5 using namespace std;
6 #define maxn 1000
7 #define maxm 1000000
8 const double inf = 1 << 30;
9 int n, m, s;
10 double l, u;
11 bool visit[maxn];
12 int eh[maxn], tot;
13 double dist[maxn];
14 struct Edge {
15     int u, v;
16     double cost;
17     int next;
18 }et[maxm];
19
20 void init() {
21     tot = 0;
22     memset(eh, -1, sizeof(eh));
23 }
24
25 void addedge(int u, int v, double cost) {
26     Edge e = {u, v, cost, eh[u]};
27     et[tot] = e;
28     eh[u] = tot++;
29 }
30 bool instack[maxn];
31 bool dfs_spfa(int u) {
32     if(instack[u]) return false;
33     instack[u] = true;
34     visit[u] = true;
35     for(int i = eh[u]; i != -1; i = et[i].next) {
36         int v = et[i].v;
37         double cost = et[i].cost;
38         if(dist[v] > dist[u] + cost) {
39             dist[v] = dist[u] + cost;
40             if(!dfs_spfa(v)) return false;
41         }
42     }
43     instack[u] = false;
44     return true;
45 }
46
47 bool solve() {
48     memset(visit, false, sizeof(visit));
49     memset(instack, false, sizeof(instack));
50     memset(dist, 0, sizeof(dist));
51     for(int i = 1; i <= n + m; i++) {
52         if(!visit[i])
53             if(!dfs_spfa(i)) return false;
54     }
55     return true;
56 }
57
58 int main() {
59     double tmp;
60     while(scanf("%d%d%lf%lf", &n, &m, &l, &u) != EOF) {
61         init();
62         for(int i = 1; i <= n; i++) {
63             for(int j = 1; j <= m; j++) {
64                 scanf("%lf", &tmp);
65                 addedge(j + n, i, log(u / tmp));
66                 addedge(i, j + n, -log(l / tmp));
67             }
68         }
69         if(solve()) printf("YES\n");
70         else printf("NO\n");
71     }
72
73     return 0;
74 }

y @ The Angry Teletubbies 2011-10-17 16:48 发表评论

poj 3207 Ikki's Story IV - Panda's Trick - 2-Sat

y @ The Angry Teletubbies — Mon, 17 Oct 2011 07:52:00 GMT

【题意】：平面上，一个圆，圆的边上按顺时针放着n个点。现在要连m条边，比如a，b，那么a到b可以从圆的内部连接，也可以从圆的外部连接。给你的信息中，每个点最多只会连接的一条边。问能不能连接这m条边，使这些边都不相交。

【题解】：题意可能刚开始不是很好理解，比如1和5连边，2和6连边，由于点是顺序排列的，一画图就可以发现，这两条边必须一个从圆外面连，一个从内部连，否则就会相交。如果再加入3和7这条边，那么就必须相交了。
              这样，我们很容易把问题转化为一个标准的2-sat问题，把每条边看成2-sat中的点，i 表示这条边从圆的内部连边，i’ 表示从圆的外部连边。
              如果某两条边 i 和 j 有矛盾关系（既只能一个从内部连边，一个从外部连边），那么我们可以这样连边: i -> j' , i' -> j, j -> i', j' -> i.
              最后判断一下有无可行解即可。

【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "vector"
5 using namespace std;
6 #define maxn 1050
7 int n, m;
8 vector<int> vec[maxn];
9 int s[maxn], top;
10 int belong[maxn], scc, dfn[maxn], low[maxn], Dindex;
11 bool instack[maxn];
12 struct Line {
13     int a, b;
14 }line[maxn];
15
16 void dfs(int u) {
17     int v, size = vec[u].size();
18     dfn[u] = low[u] = ++Dindex;
19     instack[u] = true;
20     s[++top] = u;
21     for(int i = 0; i < size; i++) {
22         v = vec[u][i];
23         if(!dfn[v]) dfs(v), low[u] = min(low[u], low[v]);
24         else if(instack[v]) low[u] = min(low[u], dfn[v]);
25     }
26     if(dfn[u] == low[u]) {
27         scc++;
28         do {
29             v = s[top--];
30             instack[v] = false;
31             belong[v] = scc;
32         }while(v != u);
33     }
34 }
35 void tarjan() {
36     top = scc = Dindex = 0;
37     memset(dfn, 0, sizeof(dfn));
38     memset(instack, 0, sizeof(instack));
39     for (int u = 0; u < 2 * m; u++)
40         if(!dfn[u]) dfs(u);
41 }
42
43 bool solvable() {
44     for(int i = 0; i < 2 * m; i += 2)
45         if(belong[i] == belong[i^1]) return false;
46     return true;
47 }
48
49 bool conflict(Line a, Line b) {
50     if(a.a > b.b || a.b < b.a || (a.a < b.a && a.b > b.b) || (a.a > b.a && a.b < b.b)) return false;
51     return true;
52 }
53
54 void build() {
55     for(int i = 0; i < m; i++) {
56         for(int j = i + 1; j < m; j++) {
57             int u = 2 * i, v = 2 * j;
58             if(conflict(line[i], line[j])) {
59                 vec[u].push_back(v^1), vec[u^1].push_back(v);
60                 vec[v].push_back(u^1), vec[v^1].push_back(u);
61             }
62         }
63     }
64 }
65
66 int main() {
67     for(int i = 0; i < maxn; i++) vec[i].clear();
68     scanf("%d%d", &n, &m);
69     for(int i = 0; i < m; i++) {
70         scanf("%d%d", &line[i].a, &line[i].b);
71         if(line[i].a > line[i].b) swap(line[i].a, line[i].b);
72     }
73     build();
74     tarjan();
75     if(solvable()) printf("panda is telling the truth\n");
76     else printf("the evil panda is lying again\n");
77     return 0;
78 }

y @ The Angry Teletubbies 2011-10-17 15:52 发表评论

poj 3648 Wedding - 2-Sat

y @ The Angry Teletubbies — Mon, 17 Oct 2011 07:35:00 GMT

【题意】：有一对新人结婚，邀请n对夫妇去参加婚礼。有一张很长的桌子，人只能坐在桌子的两边，还要满足下面的要求：1.每对夫妇不能坐在同一侧 2.n对夫妇之中可能有通奸关系（包括男男，男女，女女），有通奸关系的不能同时坐在新娘的对面，可以分开坐，可以同时坐在新娘这一侧。如果存在一种可行的方案，输出与新娘同侧的人。

【题解】：比较明显的2-sat，我们可以把问题转化为求坐在新娘对面的人的可行方案。
对于m对有通奸关系的x 和 y，连边x->y', y->x'.
最后新娘向新郎连一条边，表示新郎一定要坐在新娘的对面，然后就是解2-sat的基本步骤了，输出方案时利用染色把与新娘同色的人输出。

【代码】：

  1 #include "iostream"
  2 #include "cstring"
  3 #include "cstdio"
  4 #include "vector"
  5 using namespace std;
  6 #define maxn 5010
  7 vector<int> vec[maxn], rvec[maxn], dag[maxn];
  8 int belong[maxn], scc, top, s[maxn], color[maxn];
  9 int n, m;
10 bool visit[maxn];
11 void init() {
12     for(int i = 0; i < maxn; i++) vec[i].clear(), rvec[i].clear(), dag[i].clear();
13 }
14 int cal(int a, char ch) {
15     int res = a * 2;
16     if(ch == 'h') return res;
17     else return res + 1;
18 }
19 void dfs1(int u) {
20     visit[u] = true;
21     int size = vec[u].size();
22     for(int i = 0; i < size; i++) {
23         int v = vec[u][i];
24         if(!visit[v]) dfs1(v);
25     }
26     s[++top] = u;
27 }
28 void dfs2(int u) {
29     visit[u] = true;
30     int size = rvec[u].size();
31     for(int i = 0; i < size; i++) {
32         int v = rvec[u][i];
33         if(!visit[v]) dfs2(v);
34     }
35     belong[u] = scc;
36 }
37 void kosaraju() {
38     scc = top = 0;
39     memset(visit, false, sizeof(visit));
40     for(int i = 0; i < 2 * n; i++)
41         if(!visit[i]) dfs1(i);
42     memset(visit, false, sizeof(visit));
43     for(int i = 2 * n; i; i--)
44         if(!visit[s[i]]) scc++, dfs2(s[i]);
45     for(int u = 0; u < 2 * n; u++) {
46         int size = rvec[u].size();
47         for(int i = 0; i < size; i++) {
48             int v = rvec[u][i];
49             if(belong[u] != belong[v]) dag[belong[u]].push_back(belong[v]);
50         }
51     }
52 }
53 bool solvable() {
54     for(int i = 0; i < 2 * n; i += 2)
55         if(belong[i] == belong[i+1]) return false;
56     return true;
57 }
58 void dfs(int u) {
59     color[u] = 2;
60     int size = dag[u].size();
61     for(int i = 0; i < size; i++) {
62         int v = dag[u][i];
63         if(!color[v]) dfs(v);
64     }
65 }
66 void solve() {
67     memset(color, 0, sizeof(color));
68     for(int i = scc; i; i--) {
69         if(!color[i]) {
70             color[i] = 1;
71             for(int j = 0; j < 2 * n; j++) {
72                 if(belong[j] == i) {
73                     int k = belong[j^1];
74                     if(!color[k]) dfs(k);
75                 }
76             }
77         }
78     }
79     for(int i = 2; i < 2 * n; i++)
80         if(color[belong[i]] == color[belong[1]])
81             printf("%d%c ", i / 2, i & 1 ? 'w' : 'h');
82     printf("\n");
83 }
84 void debug() {
85     for(int i = 0; i < 2 * n; i++) {
86         int size = vec[i].size();
87         for(int j = 0; j < size; j++) {
88             cout << i << "->" << vec[i][j] << endl;
89         }
90     }
91     cout << endl;
92     for(int i = 1; i <= scc; i++) {
93         int size = dag[i].size();
94         for(int j = 0; j < size; j++) {
95             cout << i << "->" << dag[i][j] << endl;
96         }
97     }
98 }
99 int main() {
100     char ch1, ch2;
101     int a, b;
102     while(~scanf("%d%d", &n, &m)) {
103         getchar();
104         if(!n && !m) break;
105         init();
106         for(int i = 0; i < m; i++) {
107             scanf("%d%c%d%c", &a, &ch1, &b, &ch2);
108             getchar();
109             int u = cal(a, ch1), v = cal(b, ch2);
110             vec[u].push_back(v^1), vec[v].push_back(u^1);
111             rvec[v^1].push_back(u), rvec[u^1].push_back(v);
112         }
113         vec[1].push_back(0), rvec[0].push_back(1);
114         kosaraju();
115         if(solvable()) solve();
116         else printf("bad luck\n");
117     }
118     return 0;
119 }

y @ The Angry Teletubbies 2011-10-17 15:35 发表评论