C++博客-A Za, A Za, Fighting...-随笔分类-F_图算法

PKU 2060 Taxi Cab Scheme

simplyzhao — Wed, 20 Oct 2010 16:18:00 GMT

问题:
http://poj.org/problem?id=2060

思路:
将每一个Taxi订单作为顶点，根据题意如果订单i与订单j可以在规定时间内到达，那么说顶点i与顶点j存在一条边
最小路径覆盖问题可以转化为最大匹配问题
见: http://www.cppblog.com/Joe/archive/2010/10/21/130676.html

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 501
5 #define Abs(a) ((a)>=0 ? (a) : (a)*(-1))
6 int M;
7 int graph[MAX_LEN][MAX_LEN];
8 int state[MAX_LEN], fwd[MAX_LEN], bwd[MAX_LEN];
9 struct Taxi {
10     int hour, minu;
11     int sx, sy, dx, dy;
12 }rides[MAX_LEN];
13
14 int
15 reachable(struct Taxi *fst, struct Taxi *scd)
16 {
17     int h, m;
18     h = fst->hour;
19     m = fst->minu + Abs(fst->dx-fst->sx) + Abs(fst->dy-fst->sy) + Abs(scd->sx-fst->dx) + Abs(scd->sy-fst->dy);
20     h = (h+m/60);
21     m = m%60;
22     if(h >= 24)
23         return 0;
24     if(h == scd->hour)
25         return (m<scd->minu);
26     return (h<scd->hour);
27 }
28
29 void
30 build_graph()
31 {
32     int i, j;
33     memset(graph, 0, sizeof(graph));
34     for(i=0; i<M; i++)
35         for(j=i+1; j<M; j++)
36             if(reachable(rides+i, rides+j))
37                 graph[i][j] = 1;
38 }
39
40 int
41 find_path(int u)
42 {
43     int i;
44     for(i=0; i<M; i++) {
45         if(graph[u][i] && !state[i]) {
46             state[i] = 1;
47             if(bwd[i]==-1 || find_path(bwd[i])) {
48                 bwd[i] = u;
49                 fwd[u] = i;
50                 return 1;
51             }
52         }
53     }
54     return 0;
55 }
56
57 int
58 MaxMatch()
59 {
60     int i, ans = 0;
61     memset(fwd, -1, sizeof(fwd));
62     memset(bwd, -1, sizeof(bwd));
63     for(i=0; i<M; i++) {
64         if(fwd[i] == -1) {
65             memset(state, 0, sizeof(state));
66             if(find_path(i))
67                 ++ans;
68         }
69     }
70     return ans;
71 }
72
73 int
74 main(int argc, char **argv)
75 {
76     int i, tests;
77     scanf("%d", &tests);
78     while(tests--) {
79         scanf("%d", &M);
80         for(i=0; i<M; i++)
81             scanf("%d:%d %d %d %d %d", &rides[i].hour, &rides[i].minu, &rides[i].sx, &rides[i].sy, &rides[i].dx, &rides[i].dy);
82         build_graph();
83         printf("%d\n", M-MaxMatch());
84     }
85 }

simplyzhao 2010-10-21 00:18 发表评论

PKU 2536 Gopher II

simplyzhao — Wed, 20 Oct 2010 08:20:00 GMT

问题:
http://poj.org/problem?id=2536

思路:
典型的最大二分匹配，也是咱的第一道最大二分匹配
根据题意，在规定的时间和速度下，gopher[i]能够到达hole[j]，那么在i与j之间存在一条边，这样就建立了二分图
学习了匈牙利算法，见http://www.cppblog.com/Joe/archive/2010/10/20/130573.html

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #include<math.h>
5 #define MAX_LEN 101
6 int map[MAX_LEN][MAX_LEN];
7 int result[MAX_LEN]; /* previous matching */
8 int state[MAX_LEN];
9 int n, m, s, v;
10 struct Coordinate {
11     float x, y;
12 }gophers[MAX_LEN], holes[MAX_LEN];
13
14 int
15 findpath(int u)
16 {
17     int i;
18     for(i=0; i<m; i++) {
19         if(map[u][i] && state[i]==-1) {
20             state[i] = 1;
21             if(result[i]==-1 || findpath(result[i])) {
22                 result[i] = u; /* 取反 */
23                 return 1;
24             }
25         }
26     }
27     return 0;
28 }
29
30 int
31 MaxMatch()
32 {
33     int i, ans = 0;
34     for(i=0; i<n; i++) {
35         memset(state, -1, sizeof(state));
36         if(findpath(i))
37             ++ans;
38     }
39     return ans;
40 }
41
42 int
43 main(int argc, char **argv)
44 {
45     int i, j;
46     while(scanf("%d %d %d %d", &n, &m, &s, &v) != EOF) {
47         for(i=0; i<n; i++)
48             scanf("%f %f", &gophers[i].x, &gophers[i].y);
49         for(j=0; j<m; j++)
50             scanf("%f %f", &holes[j].x, &holes[j].y);
51
52         memset(map, 0, sizeof(map));
53         memset(result, -1, sizeof(result));
54         for(i=0; i<n; i++)
55             for(j=0; j<m; j++) {
56                 if(sqrt((holes[j].x-gophers[i].x)*(holes[j].x-gophers[i].x) + (holes[j].y-gophers[i].y)*(holes[j].y-gophers[i].y)) <= v*s) /*reachable*/
57                     map[i][j] = 1;
58                 else
59                     map[i][j] = 0;
60             }
61
62         printf("%d\n", n-MaxMatch());
63     }
64 }

simplyzhao 2010-10-20 16:20 发表评论

PKU 1273 Drainage Ditches

simplyzhao — Thu, 16 Sep 2010 13:10:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1273

思路:
第一道最大流，Edmonds-Karp算法
参考了别人的代码，其实自己也能写出来，不过肯定没有这么精致(*^__^*) 嘻嘻……
从别人的代码里学到很多，例如：
一条路径只需要pre[]数组进行保存即可，路径的残留容量也可以边扩展(BFS)边记录，还有代码居然就只需要一个残留网络的二维数组

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_M 201
5 #define INF 0x7FFFFFFF
6 #define Min(a,b) ((a)<(b) ? (a) : (b))
7 int n, m, source, sink;
8 int pre[MAX_M]; /* excellent for path recording */
9 int flow[MAX_M];
10 int residual[MAX_M][MAX_M]; /* only need this matrix */
11 int queue[MAX_M];
12
13 int
14 bfs() /* operation on the residual network */
15 {
16     int i, head, tail, cur;
17     head = -1;
18     tail = 0;
19     memset(pre, -1, sizeof(pre));
20     for(i=1; i<=m; i++)
21         flow[i] = INF;
22     queue[tail] = source;
23     pre[source] = 0;
24     while(head < tail) {
25         ++head;
26         cur = queue[head];
27         if(cur == sink)
28             return flow[sink];
29         for(i=1; i<=m; i++) {
30             if(pre[i]!=-1 || !residual[cur][i])
31                 continue;
32             pre[i] = cur;
33             flow[i] = Min(flow[cur], residual[cur][i]);
34             ++tail;
35             queue[tail] = i;
36         }
37     }
38     return -1;
39 }
40
41 int
42 edmonds_karp()
43 {
44     int tmp, next, cur, rt = 0;
45     while(1) {
46         tmp = bfs();
47         if(tmp == -1) /* there's no argment path */
48             return rt;
49         rt += tmp;
50         cur = sink;
51         while(cur != source) {
52             next = cur;
53             cur = pre[cur];
54             residual[cur][next] -= tmp;
55             residual[next][cur] += tmp;
56         }
57     }
58 }
59
60 int
61 main(int argc, char **argv)
62 {
63     int i, f, t, c, ans;
64     while(scanf("%d %d", &n, &m) != EOF) {
65         memset(residual, 0, sizeof(residual));
66         for(i=1; i<=n; i++) {
67             scanf("%d %d %d", &f, &t, &c);
68             residual[f][t] += c; /* Attention: multiple lines */
69         }
70         source = 1;
71         sink = m;
72         ans = edmonds_karp();
73         printf("%d\n", ans);
74     }
75 }

simplyzhao 2010-09-16 21:10 发表评论

PKU 1201 Intervals

simplyzhao — Mon, 13 Sep 2010 12:32:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1201

思路:
第一次写差分约束
设s[i]表示[0...i+1]中的整数在题意要求的集合中的个数，那么根据题意有(输入a, b, c):
s[b+1] - s[a] >= c
另外，还隐含约束条件:
1 >= s[i] - s[i-1] >=0
然后就是用Bellman-ford算法求可行解

我不理解的地方在于: Bellman-ford所求结果是可行解，如何保证是the minimal size of set Z
或许可以参考：
http://hi.baidu.com/zf_hi/blog/item/529b830f27099aebaa645748.html

代码(转 http://blog.163.com/lu_jian_bin2006@126/blog/static/48789281200987398473/）

1 #include<iostream>
2 #define INF 0x7fffffff
3 using namespace std;
4
5 struct {
6  int fst,sed,adj;
7  }edge[50001];
8
9 int n,mx,mn,dist[50001];
10
11 int Bellman()
12 {
13  int i,k;
14  for(i=mn;i<=mx;i++)dist[i]=0;
15
16  for(k=mn;k<=mx;k++)
17  {
18    bool flag=true;
19    for(i=1;i<=n;i++)
20      if(dist[edge[i].sed]<dist[edge[i].fst]+edge[i].adj)
21          flag=false,dist[edge[i].sed]=dist[edge[i].fst]+edge[i].adj;
22
23    for(i=mn;i<mx;i++)
24      if(dist[i]>dist[i+1])
25          dist[i+1]=dist[i],flag=false;
26
27    for(i=mx;i>mn;i--)
28      if(dist[i]-1>dist[i-1])
29          dist[i-1]=dist[i]-1,flag=false;
30
31    if(flag)break;
32  }
33  return dist[mx];
34 }
35
36 int main()
37 {
38  while(cin>>n)
39  {
40    mx=0;
41    mn=INF;
42    for(int i=1;i<=n;i++)
43    {
44       cin>>edge[i].fst>>edge[i].sed>>edge[i].adj;
45       edge[i].sed++;
46       if(edge[i].fst<mn)mn=edge[i].fst;
47       if(edge[i].sed>mx)mx=edge[i].sed;
48    }
49    cout<<Bellman()<<endl;
50  }
51  return 0;
52 }

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_E 50001
5 #define MAX_V 50002
6 #define INF 0x7FFFFFFF
7 struct Edge {
8     int from, to;
9     int cost;
10 }edges[MAX_E];
11 int n, min, max;
12 int d[MAX_V];
13
14 void
15 init()
16 {
17     int i;
18     min = INF;
19     max = 0;
20     for(i=1; i<=n; i++) {
21         scanf("%d %d %d", &edges[i].to, &edges[i].from, &edges[i].cost);
22         ++edges[i].from;
23         edges[i].cost *= (-1);
24         if(edges[i].to<min)
25             min = edges[i].to;
26         if(edges[i].from>max)
27             max = edges[i].from;
28     }
29 }
30
31 void
32 bellman_ford()
33 {
34     int i, j, flag;
35     memset(d, 0, sizeof(d)); /* the same effect to 'super souce' in CLRS */
36     for(i=min; i<=max; i++) { /* the number of verticles */
37         flag = 1;
38         /* RELAX each edge */
39         for(j=1; j<=n; j++)
40             if(d[edges[j].to] > d[edges[j].from]+edges[j].cost) {
41                 d[edges[j].to] = d[edges[j].from]+edges[j].cost;
42                 flag = 0;
43             }
44         for(j=min+1; j<=max; j++)
45             if(d[j] > d[j-1]+1) {
46                 d[j] = d[j-1]+1;
47                 flag = 0;
48             }
49         for(j=max; j>min; j--)
50             if(d[j-1] > d[j]) {
51                 d[j-1] = d[j];
52                 flag = 0;
53             }
54         if(flag)
55             break;
56     }
57 }
58
59 int
60 main(int argc, char **argv)
61 {
62     while(scanf("%d", &n) != EOF) {
63         init();
64         bellman_ford();
65         printf("%d\n", d[max]-d[min]); /* d[max]=0 */
66     }
67 }

simplyzhao 2010-09-13 20:32 发表评论

PKU 1125 Stockbroker Grapevine

simplyzhao — Sat, 11 Sep 2010 13:37:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1125

思路:
题意还是蛮简单的，第一次写Floyd-Warshall算法求每对顶点间的最短距离

代码:

1 /* Floyd-Warshall algorithm */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_N 101
6 #define INF 0x7FFFFFFF
7 #define Min(a,b) ((a)<(b) ? (a) : (b))
8 #define Max(a,b) ((a)<(b) ? (b) : (a))
9 int weight[MAX_N][MAX_N];
10 int d[MAX_N][MAX_N];
11 int max[MAX_N];
12 int n;
13
14 void
15 init()
16 {
17     int i, j, cnt, t, c;
18     memset(weight, 0, sizeof(weight));
19     for(i=1; i<=n; i++) {
20         scanf("%d", &cnt);
21         for(j=0; j<cnt; j++) {
22             scanf("%d %d", &t, &c);
23             weight[i][t] = c;
24         }
25     }
26 }
27
28 void
29 floyd_warshall() /* O(n^3) */
30 {
31     int i, j, k;
32     for(i=1; i<=n; i++)
33         for(j=1; j<=n; j++)
34             d[i][j] = (i==j?0:INF);
35     for(i=1; i<=n; i++)
36         for(j=1; j<=n; j++)
37             if(weight[i][j])
38                 d[i][j] = weight[i][j];
39     for(k=1; k<=n; k++) {
40         for(i=1; i<=n; i++) {
41             for(j=1; j<=n; j++) {
42                 if(d[i][k]!=INF && d[k][j]!=INF)
43                     d[i][j] = Min(d[i][j], d[i][k]+d[k][j]);
44             }
45         }
46     }
47 }
48
49 void
50 output()
51 {
52     int i, j, p, rt;
53     memset(max, 0, sizeof(max));
54     rt = INF;
55     for(i=1; i<=n; i++) {
56         for(j=1; j<=n; j++)
57             if(i!=j) {
58                 max[i] = Max(max[i], d[i][j]);
59             }
60         if(max[i] < rt) {
61             rt = max[i];
62             p = i;
63         }
64     }
65     if(rt == INF)
66         printf("disjoint\n");
67     else
68         printf("%d %d\n", p, rt);
69 }
70
71 int
72 main(int argc, char **argv)
73 {
74     while(scanf("%d", &n)!=EOF && n) {
75         init();
76         floyd_warshall();
77         output();
78     }
79 }

simplyzhao 2010-09-11 21:37 发表评论

PKU 1511 Invitation Cards

simplyzhao — Sat, 11 Sep 2010 11:08:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1511

思路:
第一次写SPFA，其实是在discuss里总是看到SPFA这东东，于是今天就好奇地查了下，原来是求最短路径的快速算法
除了SPFA，这题还学到了:
1. 如何静态地建立邻接表，大开眼界，原来邻接表还可以这么建的，膜拜...
2. 求一个顶点到其他各个顶点的最短路径，显然，是单源最短路径
求其他各个顶点到某一个特定顶点的最短路径，其实也是单源最短路径，只要将原始有向图逆向即可

参考:
http://www.cnblogs.com/zhangjinglei/archive/0001/01/01/1532389.html

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_N 1000005
5 #define INF 0x7FFFFFFF
6 struct Edge { /* build adj-list statically */
7     int to;
8     int cost;
9     int next;
10 };
11 struct Edge edges[MAX_N], op_edges[MAX_N];
12 int assist[MAX_N], op_assist[MAX_N];
13 int mark[MAX_N], d[MAX_N];
14 int queue[MAX_N];
15 int P, Q;
16
17 void
18 init()
19 {
20     int i, f, t, c;
21     scanf("%d %d", &P, &Q);
22     memset(assist, -1, sizeof(assist));
23     memset(op_assist, -1, sizeof(op_assist));
24     for(i=0; i<Q; i++) {
25         scanf("%d %d %d", &f, &t, &c);
26         edges[i].to = t;
27         edges[i].cost = c;
28         edges[i].next = assist[f];
29         assist[f] = i;
30         /* reverse graph */
31         op_edges[i].to = f;
32         op_edges[i].cost = c;
33         op_edges[i].next = op_assist[t];
34         op_assist[t] = i;
35     }
36 }
37
38 long long
39 spfa(struct Edge *e, int *ass, int begin)
40 {
41     int i, j, head, tail, cur;
42     memset(mark, 0, sizeof(mark));
43     for(i=1; i<=P; i++)
44         d[i] = INF;
45     head = -1;
46     tail = 0;
47     d[begin] = 0;
48     mark[begin] = 1;
49     queue[tail] = begin;
50     while(head < tail) {
51         ++head;
52         cur = queue[head];
53         mark[cur] = 0;
54         for(j=ass[cur]; j!=-1; j=e[j].next) {
55             if(d[e[j].to] > d[cur]+e[j].cost) {
56                 d[e[j].to] = d[cur] + e[j].cost;
57                 if(!mark[e[j].to]) {
58                     ++tail;
59                     queue[tail] = e[j].to;
60                     mark[e[j].to] = 1;
61                 }
62             }
63         }
64     }
65     long long rt = 0;
66     for(i=1; i<=P; i++)
67         rt += d[i];
68     return rt;
69 }
70
71 int
72 main(int argc, char **argv)
73 {
74     int tests;
75     scanf("%d", &tests);
76     while(tests--) {
77         init();
78         printf("%lld\n", spfa(edges, assist, 1)+spfa(op_edges, op_assist, 1));
79     }
80 }

simplyzhao 2010-09-11 19:08 发表评论

PKU 3463 Sightseeing

simplyzhao — Sat, 11 Sep 2010 08:31:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=3463

思路:
该题不会，查看别人思路后发现又是DP+Dijkstra
DP真的是相当相当地强大啊...

参考:
http://hi.baidu.com/scameeling/blog/item/c06f15f0f44e3418b07ec5fe.html
http://www.cnblogs.com/zhangjinglei/archive/2009/07/31/1536160.html

转载:

dp[i][1]表示到达点i最短的路有多少条，dp[i][2]表示次短的条数

dist[i][1]表示到达点i最短路的长度,dist[i][2].........................

初始化为dist[st][1]=0 其他为max_int dp[st][1]=1 其他为0

用v去松驰u时有四种情况 (设当前dist[v][cas])

情况1：dist[v][cas]+w(v,u)

dist[u][2]=dist[u][1]

dist[u][1]=dist[v][cas]+w(v,u);

dp[u][2]=dp[u][1]

dp[u][1]=dp[v][cas]，

把Node(dist[u][1],u,1)和Node(dist[u][2],u,2)放入队列

情况2：dist[v][cas]+w(v,u)==dist[u][1]，找到一条新的相同距离的最短路，则dp[u][1]+=dp[v][cas],其他不用更新,也不入队

情况3：dist[v][cas]+w(v,u)

dist[u][2]=dist[v][cas]+w(v,u);

dp[u][2]=dp[v][cas];

把Node(dist[u][2],u,2)放入队列

情况4：dist[v][cas]+w(v,u)==dist[u][2] 找到一条新的相同距离的次短路,则dp[u][2]+=dp[v][cas],其他不更新。

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_N 1001
5 #define INF 0x7FFFFFFF
6 int d[MAX_N][2], in[MAX_N][2], cnt[MAX_N][2];
7 int n, m, from, to;
8 struct Node {
9     int target, cost;
10     struct Node *next;
11 };
12 struct Node *nodes[MAX_N]; /* adj list: there may be different roads between city A and city B */
13
14 void
15 init()
16 {
17     int i, f, t, c;
18     struct Node *fresh;
19     memset(nodes, 0, sizeof(nodes));
20     scanf("%d %d", &n, &m);
21     for(i=0; i<m; i++) {
22         scanf("%d %d %d", &f, &t, &c);
23         fresh = (struct Node *)malloc(sizeof(struct Node));
24         fresh->target = t;
25         fresh->cost = c;
26         fresh->next = nodes[f];
27         nodes[f] = fresh;
28     }
29     scanf("%d %d", &from, &to);
30 }
31
32 void
33 dijkstra()
34 {
35     int i, j, k, p, min, v, cur;
36     struct Node *tmp;
37     memset(in, 0, sizeof(in));
38     memset(cnt, 0, sizeof(cnt));
39     /* d[i][0]: minimum path, d[i][1]: second minimum path */
40     for(i=1; i<=n; i++)
41         d[i][0] = d[i][1] = INF;
42     d[from][0] = 0;
43     cnt[from][0] = 1;
44     for(i=1; i<=2*n; i++) { /* each vertex has two chance to relax */
45         min = INF;
46         p = -1;
47         for(j=1; j<=n; j++) {
48             if(!in[j][0] && d[j][0]<min) {
49                 min = d[j][0];
50                 p = j;
51                 k = 0;
52             } else if(!in[j][1] && d[j][1]<min) {
53                 min = d[j][1];
54                 p = j;
55                 k = 1;
56             }
57         }
58         if(p == -1)
59             break;
60         in[p][k] = 1;
61         tmp = nodes[p];
62         while(tmp != NULL) { /* Relax */
63             v = tmp->target;
64             cur = d[p][k] + tmp->cost;
65             if(cur < d[v][0]) {
66                 d[v][1] = d[v][0];
67                 cnt[v][1] = cnt[v][0];
68                 d[v][0] = cur;
69                 cnt[v][0] = cnt[p][k];
70             } else if(cur == d[v][0]) {
71                 cnt[v][0] += cnt[p][k];
72             } else if(cur < d[v][1]) {
73                 d[v][1] = cur;
74                 cnt[v][1] = cnt[p][k];
75             } else if(cur == d[v][1]) {
76                 cnt[v][1] += cnt[p][k];
77             }
78             tmp = tmp->next;
79         }
80     }
81 }
82
83 int
84 main(int argc, char **argv)
85 {
86     int tests, rt;
87     scanf("%d", &tests);
88     while(tests--) {
89         init();
90         dijkstra();
91         rt = cnt[to][0];
92         if(d[to][0]+1 == d[to][1])
93             rt += cnt[to][1];
94         printf("%d\n", rt);
95     }
96 }

simplyzhao 2010-09-11 16:31 发表评论

PKU 2263 Heavy Cargo

simplyzhao — Fri, 10 Sep 2010 10:54:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2263

思路:
这题，我自己的想法是更像DP，设源点是source，d[i]表示从source到顶点i的每条路径中的最小值的最大值，即该题要求的结果
d[i] = max (d[i], min(d[k], adj[k][i]))，其中顶点k是从source到顶点i的路径中顶点i的前趋
具体编程的话，更像是Dijkstra的方式，只不过这里所有的顶点都必须更新

另外，这题还用到了字符串哈希，来将每个顶点用一个整数表示

代码:

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #define MAX_N 201
  5 #define MAX_LEN 31
  6 #define INF 0x7FFFFFFF
  7 #define HASH_LEN 19999
  8 #define Min(a, b) ((a)<(b) ? (a) : (b))
  9 #define Max(a, b) ((a)<(b) ? (b) : (a))
10 int n, r, hash_val;
11 int from, to, adj[MAX_N][MAX_N];
12 int d[MAX_N], in[MAX_N];
13 struct City{
14     char name[MAX_LEN];
15     int num;
16 } cities[MAX_N];
17 struct Node {
18     int index;
19     struct Node *next;
20 };
21 struct Node *hash[HASH_LEN] = {NULL};
22
23 int ELFHash(char *str)
24 {
25     unsigned long t, hash = 0;
26     while(*str) {
27         hash = (hash<<4) + (*str++);
28         if((t = hash&0xF0000000L))
29             hash ^= t>>24;
30         hash &= ~t;
31     }
32     return (hash & 0x7FFFFFFF)%HASH_LEN;
33 }
34
35 void
36 insert(int index)
37 {
38     struct Node *node = (struct Node *)malloc(sizeof(struct Node));
39     node->index = index;
40     node->next = hash[hash_val];
41     hash[hash_val] = node;
42 }
43
44 int
45 search(char *str)
46 {
47     struct Node *node = hash[hash_val];
48     while(node != NULL) {
49         if(strcmp(str, cities[node->index].name) == 0)
50             return cities[node->index].num;
51         node = node->next;
52     }
53     return -1;
54 }
55
56 void
57 init()
58 {
59     int i, j, mark, f, t, c;
60     char str[MAX_LEN];
61     memset(hash, 0, sizeof(hash));
62     memset(adj, 0, sizeof(adj));
63     for(j=0, mark=1, i=0; i<r; i++) {
64         scanf("%s", cities[j].name);
65         hash_val = ELFHash(cities[j].name);
66         if((f=search(cities[j].name)) == -1) {
67             insert(j);
68             cities[j].num = mark++;
69             f = cities[j].num;
70             j++;
71         }
72         scanf("%s", cities[j].name);
73         hash_val = ELFHash(cities[j].name);
74         if((t=search(cities[j].name)) == -1) {
75             insert(j);
76             cities[j].num = mark++;
77             t = cities[j].num;
78             j++;
79         }
80         scanf("%d", &c);
81         if(adj[f][t] < c)
82             adj[f][t] = adj[t][f] = c;
83     }
84     scanf("%s", str);
85     hash_val = ELFHash(str);
86     from = search(str);
87     scanf("%s", str);
88     hash_val = ELFHash(str);
89     to = search(str);
90 }
91
92 void
93 solve()
94 {
95     int i, j, k, tmp;
96     memset(in, 0, sizeof(in));
97     for(i=1; i<=n; i++)
98         d[i] = 0;
99     d[from] = INF;
100     in[from] = 1;
101     for(i=1; i<=n; i++) {
102         if(adj[from][i])
103             d[i] = adj[from][i];
104     }
105
106     k = n-1;
107     while(k > 0) {
108         for(i=1; i<=n; i++) {
109             if(!in[i] && d[i]!=0) {
110                 for(j=1; j<=n; j++) {
111                     if(adj[i][j]) {
112                         tmp = Min(d[i], adj[i][j]);
113                         d[j] = Max(d[j], tmp);
114                     }
115                 }
116                 in[i] = 1;
117                 --k;
118             }
119         }
120     }
121 }
122
123 int
124 main(int argc, char **argv)
125 {
126     int tests = 0;
127     while(scanf("%d %d", &n, &r) != EOF) {
128         if(n==0 && r==0)
129             break;
130         init();
131         solve();
132         printf("Scenario #%d\n%d tons\n\n", ++tests, d[to]);
133     }
134 }

simplyzhao 2010-09-10 18:54 发表评论

PKU 1158 Traffic Lights

simplyzhao — Thu, 09 Sep 2010 12:25:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1158

思路:
按照Dijkstra算法的思路来求解，关键是每确定一个顶点的更新操作需要考虑因为交通灯导致的等待时间
算法本身并不复杂，自己写出来以后一直TLE...
分析之后的原因是计算两个junctions之间等待交通灯一致所需要等待的时间这一代码块会导致超时
我自己的naive想法是依次递增等待时间(加1)，然后检查交通灯是否一致
去图书馆看书的时候突然想到可以取模，但本质还是递增检查，结果还是TLE

参考了别人代码后发现，在取模之后，就可以分情况讨论，直接得出等待时间

参考:
http://blog.sina.com.cn/s/blog_5c95cb070100cxtr.html

代码:

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #define MAX_N 301
  5 #define INF 0x7FFFFFFF
  6 #define Min(a, b) ((a)<(b) ? (a) : (b))
  7 struct Junction {
  8     int color; /* 0: blue, 1: purple */
  9     int left;
10     int dur[2]; /* 0: blue, 1: purple */
11 }junctions[MAX_N];
12 int from, to;
13 int n, m;
14 int adj[MAX_N][MAX_N], d[MAX_N], in[MAX_N];
15
16 void
17 find_color(int index, int past, int *color, int *left) /* past: the time past from 0 */
18 {
19     int i;
20     if(past < junctions[index].left) {
21         *color = junctions[index].color;
22         *left = junctions[index].left - past;
23         return;
24     }
25     past -= junctions[index].left;
26     past = past%(junctions[index].dur[0] + junctions[index].dur[1]);
27     if(junctions[index].color == 0) {
28         if(past<junctions[index].dur[1]) {
29             *color = 1;
30             *left = junctions[index].dur[1] - past;
31         } else {
32             *color = 0;
33             *left = junctions[index].dur[0] + junctions[index].dur[1] - past;
34         }
35     }
36     else {
37         if(past<junctions[index].dur[0]) {
38             *color = 0;
39             *left = junctions[index].dur[0] - past;
40         } else {
41             *color = 1;
42             *left = junctions[index].dur[0] + junctions[index].dur[1] - past;
43         }
44     }
45 }
46
47 void
48 update(int index, int bt) /* bt: the beginning time for current update */
49 {
50     int i, tm, color_a, color_b, left_a, left_b;
51     for(i=1; i<=n; i++) {
52         if(!in[i] && adj[index][i] && d[i]>bt+adj[index][i]) {
53             find_color(index, bt, &color_a, &left_a);
54             find_color(i, bt, &color_b, &left_b);
55             if(color_a == color_b)
56                 tm = 0;
57             else {
58                 if(left_a != left_b)
59                     tm = Min(left_a, left_b);
60                 else {
61                     if(color_a == 0) {
62                         if(junctions[index].dur[1] != junctions[i].dur[0])
63                             tm = left_a + Min(junctions[index].dur[1], junctions[i].dur[0]);
64                         else if(junctions[index].dur[0] != junctions[i].dur[1])
65                             tm = left_a + junctions[index].dur[1] + Min(junctions[index].dur[0], junctions[i].dur[1]);
66                         else
67                             tm = INF;
68                     }
69                     else {
70                         if(junctions[index].dur[0] != junctions[i].dur[1])
71                             tm = left_a + Min(junctions[index].dur[0], junctions[i].dur[1]);
72                         else if(junctions[index].dur[1] != junctions[i].dur[0])
73                             tm = left_a + junctions[index].dur[0] + Min(junctions[index].dur[1], junctions[i].dur[0]);
74                         else
75                             tm = INF;
76                     }
77                 }
78             }
79             if(tm!=INF && d[i]>d[index]+adj[index][i]+tm)
80                 d[i] = d[index]+adj[index][i]+tm;
81         }
82     }
83 }
84
85 void
86 dijkstra(int source)
87 {
88     int i, j, k, cur;
89     memset(in, 0, sizeof(in));
90     for(i=1; i<=n; i++)
91         d[i] = INF;
92     in[source] = 1;
93     d[source] = 0;
94     update(source, 0);
95     for(i=2; i<=n; i++) {
96         cur = INF;
97         for(j=1; j<=n; j++)
98             if(!in[j] && d[j]<=cur) {
99                 k = j;
100                 cur = d[j];
101             }
102         in[k] = 1;
103         if(k == to)
104             break;
105         if(d[k] != INF)
106             update(k, d[k]);
107     }
108 }
109
110 void
111 input_init()
112 {
113     int i, f, t, c;
114     char tmp[2];
115     scanf("%d %d", &n, &m);
116     for(i=1; i<=n; i++) {
117         scanf("%s %d %d %d", tmp, &junctions[i].left, &(junctions[i].dur[0]), &(junctions[i].dur[1]));
118         junctions[i].color = (tmp[0]=='B' ? 0 : 1);
119     }
120     memset(adj, 0, sizeof(adj));
121     for(i=0; i<m; i++) {
122         scanf("%d %d %d", &f, &t, &c);
123         adj[f][t] = c;
124         adj[t][f] = c;
125     }
126 }
127
128 int
129 main(int argc, char **argv)
130 {
131     while(scanf("%d %d", &from, &to) != EOF) {
132         input_init();
133         dijkstra(from);
134         printf("%d\n", d[to]==INF ? 0 : d[to]);
135     }
136 }

simplyzhao 2010-09-09 20:25 发表评论

PKU 3259 Wormholes

simplyzhao — Tue, 07 Sep 2010 14:29:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=3259

思路:
这题的描述挺有意思，通过某些路径可以回到过去之类，其实就是求是否存在负权回路的问题
Bellman-Ford算法的典型应用
一个问题是，Bellman-Ford用于判断从某个源点可达的负权回路，而这里求的是整个图，而且也没有说明该图一定是connected的
解决上述问题的一个方法就是添加一个顶点，然后从该新顶点到每个其他顶点添加一条权值为0的边

代码:

1 /* Bellman-Ford algorithm */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_N 501
6 #define MAX_M 2501
7 #define MAX_W 201
8 #define INF 0x7FFFFFFF
9 struct Edge {
10     int from, to;
11     int cost;
12 } edges[MAX_M*2+MAX_W+MAX_N];
13 int d[MAX_N];
14 int n, total;
15
16 void
17 init()
18 {
19     int i, m, w, f, t, c;
20     scanf("%d %d %d", &n, &m, &w);
21     total = 0; /* the number of edges */
22     for(i=0; i<m; i++) {
23         scanf("%d %d %d", &f, &t, &c);
24         edges[total].from = f;
25         edges[total].to = t;
26         edges[total++].cost = c;
27         edges[total].from = t;
28         edges[total].to = f;
29         edges[total++].cost = c;
30     }
31     for(i=0; i<w; i++) {
32         scanf("%d %d %d", &f, &t, &c);
33         edges[total].from = f;
34         edges[total].to = t;
35         edges[total++].cost = c*(-1);
36     }
37     /* in order to keep connectivity, add one vertex: '0' */
38     for(i=1; i<=n; i++) {
39         edges[total].from = 0;
40         edges[total].to = i;
41         edges[total++].cost = 0;
42     }
43 }
44
45 void
46 relax(struct Edge *e)
47 {
48     if(d[e->from] == INF)
49         return;
50     if(d[e->to] > d[e->from]+e->cost)
51         d[e->to] = d[e->from]+e->cost;
52 }
53
54 int
55 bellman_ford()
56 {
57     int i, j;
58     for(i=0; i<=n; i++)
59         d[i] = INF;
60     d[0] = 0;
61     for(i=0; i<n; i++)  /* n+1 vertices */
62         for(j=0; j<total; j++)  /* 2*m+w+n edges */
63             relax(edges+j);
64     for(j=0; j<total; j++) {
65         if(d[edges[j].to] > d[edges[j].from]+edges[j].cost)
66             return 0;
67     }
68     return 1;
69 }
70
71 int
72 main(int argc, char **argv)
73 {
74     int F;
75     scanf("%d", &F);
76     while(F--) {
77         init();
78         printf("%s\n", bellman_ford()==1?"NO":"YES");
79     }
80 }

simplyzhao 2010-09-07 22:29 发表评论

PKU 2394 Checking an Alibi

simplyzhao — Tue, 07 Sep 2010 12:18:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2394

思路:
题目说的有点复杂，其实就是求单源最短路径，Dijkstra算法
需要注意的是输入可能有重边
具体关于Dijkstra算法，参考算法导论，有详细的证明
第一次写该算法，一次AC o(∩_∩)o...哈哈

代码:

1 /* dijkstra algorithm */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_F 501
6 #define MAX_C 101
7 #define INF 0x7FFFFFFF
8 int adj[MAX_F][MAX_F];
9 int pos[MAX_C];
10 int in[MAX_F], d[MAX_F];
11 int f, p, c, m;
12
13 void
14 init()
15 {
16     int i, from, to, cost;
17     memset(adj, 0, sizeof(adj));
18     scanf("%d %d %d %d", &f, &p, &c, &m);
19     for(i=0; i<p; i++) {
20         scanf("%d %d %d", &from, &to, &cost);
21         if(adj[from][to]==0 || adj[from][to]>cost)
22             adj[from][to] = adj[to][from] = cost;
23     }
24     for(i=1; i<=c; i++)
25         scanf("%d", pos+i);
26 }
27
28 void
29 dijkstra()
30 {
31     int i, j, k, cur;
32     memset(in, 0, sizeof(in));
33     for(i=1; i<=f; i++)
34         d[i] = INF;
35     d[1] = 0;
36     in[1] = 1;
37     for(j=1; j<=f; j++)
38         if(!in[j] && adj[1][j])
39             d[j] = adj[1][j];
40     for(i=2; i<=f; i++) {
41         cur = INF;
42         for(j=1; j<=f; j++)
43             if(!in[j] && d[j]<=cur) {
44                 k = j;
45                 cur = d[j];
46             }
47         in[k] = 1;
48         for(j=1; j<=f; j++)
49             if(!in[j] && adj[k][j] && d[k]!=INF)
50                 if(d[j] > d[k]+adj[k][j])
51                     d[j] = d[k]+adj[k][j];
52     }
53 }
54
55 void
56 output()
57 {
58     int i, n = 0;
59     for(i=1; i<=c; i++)
60         if(d[pos[i]] <= m) {
61             ++n;
62             pos[i] = -1;
63         }
64     printf("%d\n", n);
65     for(i=1; i<=c; i++)
66         if(pos[i] == -1)
67             printf("%d\n", i);
68 }
69
70 int
71 main(int argc, char **argv)
72 {
73     init();
74     dijkstra();
75     output();
76 }

simplyzhao 2010-09-07 20:18 发表评论

PKU 2421 Constructing Roads

simplyzhao — Sun, 05 Sep 2010 11:58:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=2421

思路:
非常类似于PKU 2485 Highways
区别在于: "there are already some roads between some villages"
如何在求最小生成树的算法中体现某些路径已经存在了呢？
对于Prim算法，只要将已经存在的路径(u, v)的权重设置为0即可（为什么？）
对于Kruskal算法，比较容易理解，只要将已经存在的路径(u, v)进行Union操作即可，即将u, v看作是一个连通域

simplyzhao 2010-09-05 19:58 发表评论

PKU 1861 Network/PKU 2485 Highways

simplyzhao — Sun, 05 Sep 2010 05:09:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1861
http://acm.pku.edu.cn/JudgeOnline/problem?id=2485

思路:
这里题目并没有明确要求求最小生成树，而是要求一颗最长边最小的生成树
我们可以证明:
如果T是一颗最小生成树，那么T所包含的最长边一定是所有生成树中最小的，即最小生成树满足题目要求
Prove:
如果T的最长边(x, y)并非最小
那么，存在一颗生成树R，其最长边(u, v)<(x, y)，即生成树R的任何一条边都小于(x, y)
现在，采用剪切-粘帖的方法来证明T不是一颗最小生成树，即矛盾
将T中的最长边(x, y)剪切掉，这样就得到两颗子树
在R中，至少存在一条边(p, q)可以将这两颗子树连接起来，这样就得到:
T - (x, y) + (p, q) < T

代码(这里采用Kruskal算法，并查集实现)

1 /* union-find sets, Kruskal algorithm */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_N 1001
6 #define MAX_M 15001
7 struct Edge{
8     int len;
9     int from, to;
10 }edges[MAX_M];
11 int parent[MAX_N], rank[MAX_N];
12 int n, m;
13
14 void
15 make_set()
16 {
17     int i;
18     for(i=1; i<=n; i++)
19         parent[i] = i;
20     memset(rank, 0, sizeof(rank));
21 }
22
23 int
24 find(int x)
25 {
26     int tmp, rt = x;
27     while(parent[rt] != rt)
28         rt = parent[rt];
29     while(x != rt) {
30         tmp = parent[x];
31         parent[x] = rt;
32         x = tmp;
33     }
34     return rt;
35 }
36
37 void
38 Union(int x, int y)
39 {
40     int a = find(x);
41     int b = find(y);
42     if(a == b)
43         return;
44     if(rank[a] > rank[b])
45         parent[b] = a;
46     else {
47         parent[a] = b;
48         if(rank[a] == rank[b])
49             ++rank[b];
50     }
51 }
52
53 int
54 compare(const void *arg1, const void *arg2)
55 {
56     return ((struct Edge *)arg1)->len - ((struct Edge *)arg2)->len;
57 }
58
59 void
60 init()
61 {
62     int i;
63     for(i=0; i<m; i++)
64         scanf("%d %d %d", &edges[i].from, &edges[i].to, &edges[i].len);
65     qsort(edges, m, sizeof(struct Edge), compare);
66 }
67
68 void
69 kruskal()
70 {
71     int i, a, b, count = 0;
72     int mark[MAX_N];
73     make_set();
74     for(i=0; i<m; i++) {
75         a = find(edges[i].from);
76         b = find(edges[i].to);
77         if(a != b) {
78             mark[count++] = i;
79             Union(a, b);
80         }
81     }
82     /* output */
83     printf("%d\n", edges[mark[count-1]].len);
84     printf("%d\n", count);
85     for(i=0; i<count; i++)
86         printf("%d %d\n", edges[mark[i]].from, edges[mark[i]].to);
87 }
88
89 int
90 main(int argc, char **argv)
91 {
92     while(scanf("%d %d", &n, &m) != EOF) {
93         init();
94         kruskal();
95     }
96 }

simplyzhao 2010-09-05 13:09 发表评论

PKU 1251 Jungle Roads/PKU 1258 Agri-Net

simplyzhao — Sat, 04 Sep 2010 16:09:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1251
http://acm.pku.edu.cn/JudgeOnline/problem?id=1258

思路:
最简单典型的最小生成树，PRIM算法
参考算法导论

代码(pku 1251):

1 /* MST problem */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_LEN 27
6 #define INF 0x7FFFFFFF
7 int num, min;
8 int adj[MAX_LEN][MAX_LEN];
9 int key[MAX_LEN], in[MAX_LEN];
10
11 void
12 init()
13 {
14     int i, j, k, dis;
15     char tmp[2], tmp1[2];
16     memset(adj, 0, sizeof(adj));
17     memset(in, 0, sizeof(in));
18     min = 0;
19     for(i=0; i<num; i++)
20         key[i] = INF;
21     for(i=0; i<num-1; i++) {
22         scanf("%s %d", tmp, &k);
23         for(j=0; j<k; j++) {
24             scanf("%s %d", tmp1, &dis);
25             adj[tmp[0]-'A'][tmp1[0]-'A'] = dis;
26             adj[tmp1[0]-'A'][tmp[0]-'A'] = dis;
27         }
28     }
29 }
30
31 void
32 prim()
33 {
34     int i, j, k, cur;
35     /* start from vertex 'A' */
36     in[0] = 1;
37     for(i=1; i<num; i++)
38         if(adj[0][i])
39             key[i] = adj[0][i];
40     for(i=1; i<num; i++) { /* num-1 vertex left */
41         cur = INF;
42         for(j=0; j<num; j++) {
43             if(!in[j] && key[j]<cur) {
44                 cur = key[j];
45                 k = j;
46             }
47         }
48         min += cur;
49         in[k] = 1;
50         for(j=0; j<num; j++) {
51             if(adj[k][j]) {
52                 if(!in[j] && adj[k][j]<key[j])
53                     key[j] = adj[k][j];
54             }
55         }
56     }
57 }
58
59 int
60 main(int argc, char **argv)
61 {
62     while(scanf("%d", &num)!=EOF && num) {
63         init();
64         prim();
65         printf("%d\n", min);
66     }
67 }

simplyzhao 2010-09-05 00:09 发表评论

PKU 3687 Labeling Balls

simplyzhao — Sat, 04 Sep 2010 03:35:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=3687

思路:
这题理解起来就很困难，等理解透了也还是不会

参考:
http://hi.baidu.com/archersfate/blog/item/30e66f76734a0c12b051b9ab.html

总结:
逆向的拓扑排序，等同于对转置图进行正向的拓扑排序（其实就是入度与出度的区别）
DFS实现拓扑排序适合于求出所有可能的解
BFS实现拓扑排序适合于求出满足特定要求的解

代码:

1 /* cpp: priority_queue */
2 #include<iostream>
3 #include<queue>
4 #include<vector>
5 #include<functional>
6 #include<cstdio>
7 #include<cstring>
8 using namespace std;
9
10 #define MAX_N 201
11 int n, m;
12 int adj[MAX_N][MAX_N];
13 int out_degree[MAX_N], topo[MAX_N], ans[MAX_N];
14
15 void
16 init()
17 {
18     int i, pre, suc;
19     memset(adj, 0, sizeof(adj));
20     memset(out_degree, 0, sizeof(out_degree));
21     scanf("%d %d", &n, &m);
22     for(i=0; i<m; i++) {
23         scanf("%d %d", &pre, &suc);
24         if(!adj[pre][suc]) { /* avoid duplicates */
25             adj[pre][suc] = 1;
26             ++out_degree[pre];
27         }
28     }
29 }
30
31 void
32 reverse_topo_sort()
33 {
34     int i, tmp, count = 0;
35     priority_queue<int, vector<int>, less<int> > Q;
36     for(i=1; i<=n; i++)
37         if(out_degree[i] == 0)
38             Q.push(i);
39     while(!Q.empty()) { /* BFS */
40         tmp = Q.top();
41         Q.pop();
42         topo[++count] = tmp;
43         for(i=1; i<=n; i++)
44             if(adj[i][tmp]) {
45                 --out_degree[i];
46                 if(!out_degree[i])
47                     Q.push(i);
48             }
49     }
50     if(count != n) { /* not DAG */
51         printf("-1\n");
52         return;
53     }
54     for(i=1; i<=n; i++)
55         ans[topo[n-i+1]] = i;
56     for(i=1; i<=n; i++)
57         printf("%d ", ans[i]);
58     printf("\n");
59 }
60
61 int
62 main(int argc, char **argv)
63 {
64     int tests;
65     scanf("%d", &tests);
66     while(tests--) {
67         init();
68         reverse_topo_sort();
69     }
70 }

转载:
PKU 3687 在基本的拓扑排序的基础上又增加了一个要求：编号最小的节点要尽量排在前面；在满足上一个条件的基础上，编号第二小的节点要尽量排在前面；在满足前两个条件的基础上，编号第三小的节点要尽量排在前面……依此类推。（注意，这和字典序是两回事，不可以混淆。）

如图 1 所示，满足要求的拓扑序应该是：6 4 1 3 9 2 5 7 8 0。

图 1 一个拓扑排序的例子

一般来说，在一个有向无环图中，用 BFS 进行拓扑排序是比较常见的

做法

做法，如算法 1 所示。但是它不一定能得到本题要求的拓扑序。

1. 把所有入度为 0 的节点放进队列 Q
2. WHILE： Q 不是空队列
3.       从 Q 中取出队列首元素 a，把 a 添加到答案的尾部。
4.       FOR：所有从 a 出发的边 a → b
5.           把 b 的入度减 1。如果 b 的入度变为 0，则把 b 放进队列 Q。

算法 1 用 BFS 进行拓扑排序

    为了解决本问题，下面让我来探究一下拓扑序的一些性质。以图 1 为例，节点 0 毫无疑问排在最后。除了节点 0 以外，有三条互相平行的路径：6 → 4 → 1、 3→ 9 → 2 和 5 → 7 → 8。一条路径上的各个节点的先后关系都是不能改变的，比如路径 6 → 4 → 1 上的三个节点在拓扑序中，一定是 6 在最前，1 在最后。但是，互相平行的各条路径，在总的拓扑序中任意交错都是合法的。比如，以下都是图 1 的合法拓扑序：

    6 4 1 3 9 2 5 7 8 0、 3 6 9 4 5 1 7 8 2 0、 5 6 4 7 3 8 1 9 2 0、 3 5 6 4 1 7 9 2 8 0、 6 5 7 8 4 3 9 2 1 0。

    怎么才能找出题目要求的拓扑序呢？在这里，我想用字典序最先的拓扑序来引出这个算法。算法 2 可以求出字典序最先的拓扑序。

1. 把所有入度为 0 的节点放进优先队列 PQ
2. WHILE： PQ 不是空队列
3.     从 PQ 中取出编号最小的元素 a，把 a 添加到答案的尾部。
4.     FOR：所有从 a 出发的边 a → b
5.         把 b 的入度减 1。如果 b 的入度变为 0，则把 b 放进优先队列 PQ。

算法 2 求出字典序最先的拓扑序

可见，算法 2 和算法 1 基本一样，只是把队列改成了优先队列。用它求出的图 1 的字典序最先的拓扑序为：3 5 6 4 1 7 8 9 2 0。但是这显然不是本题要求的答案，因为节点 1 的位置还不够靠前。

算法 2 可以算是一个贪心算法，每一步都找编号最小的节点。但是对于图 1 中的三条路径，头的编号比较小的，不一定要先出队列。正确的步骤应该如下：

节点 0 的位置是铁定在最后的，不用考虑。只考虑剩下的三条路径。
先找编号最小的，节点 1。把它和它所在的路径中位于它前面的节点全部拿出来。目前的答案是 6 4 1，这样，节点 1 就尽量靠前了。
再找剩下的节点中编号最小的，节点 2。把它和它所在的路径中位于它前面的节点全部拿出来。目前的答案是 6 4 1 3 9 2 ，这样，节点 2 就尽量靠前了。
只剩下一条路径了，只能依次把其中的节点拿出来。最后答案就是 6 4 1 3 9 2 5 7 8 0。

显然，算法 2 的贪心策略对于这个问题是不可行的。不能着眼于每条路径的头，而是要找编号最小的节点在哪条路径上，优先把这条路径拿出来。但问题在于，在 BFS 的过程中，我们只能看到每条路径的头，看不到后面的节点，这该怎么办呢？

让我们换个角度想一想，节点 3 和 6，应该是 6 先出队列，因为节点 1 在 6 的后面。这和节点 3 和 6 的编号大小没有任何关系。但是，再看另外两条路径的尾部，节点 2 和 8，可以肯定地说，2 一定先出队列，因为它们后面都没有别的节点了，这个时候完全以这两个节点本身的编号大小决定顺序。归纳起来就是说，对于若干条平行的路径，小的头部不一定排在前面，但是大的尾部一定排在后面。于是，就有了算法 3。

1. 把所有出度为 0 的节点放进优先队列 PQ
2. WHILE： PQ 不是空队列
3.     从 PQ 中取出编号最大的元素 a，把 a 添加到答案的头部。
4.       FOR：所有指向 a 的边 b → a
5.          把 b 的出度减 1。如果 b 的出度变为 0，则把 b 放进优先队列 PQ。

算法 3 求出本题目要求的拓扑序

我觉得这道题目确实挺奥妙的，我搞了很久才想通算法 3 为什么是正确的，特地在此写一下。

simplyzhao 2010-09-04 11:35 发表评论

PKU 1128 Frame Stacking

simplyzhao — Fri, 03 Sep 2010 08:42:00 GMT

问题:
http://acm.pku.edu.cn/JudgeOnline/problem?id=1128

思路:
想法是有：先找出没有被任何其他frame覆盖的frame，然后将该frame进行标记，使之匹配任何字母，然后重复以上过程
不过，程序不知道该如何写

参考discuss以及其他人思路，发现可以用拓扑排序来做（拓扑排序，参考算法导论)
如何根据输入来建立邻接矩阵比较有意思，另外根据各个顶点的入度DFS实现拓扑排序

代码:

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #define MAX_LEN 31
  5 #define MAX_NUM 27
  6 char map[MAX_LEN][MAX_LEN];
  7 int n, m;
  8 int adj[MAX_NUM][MAX_NUM], num, in[MAX_NUM], visited[MAX_NUM];
  9 int x1, y1, x2, y2;
10
11 void
12 search(char ch)
13 {
14     int i, j;
15     x1 = y1 = MAX_LEN;
16     x2 = y2 = -1;
17     for(i=0; i<n; i++)
18         for(j=0; j<m; j++)
19             if(map[i][j] == ch) {
20                 if(i<x1) x1 = i;
21                 if(i>x2) x2 = i;
22                 if(j<y1) y1 = j;
23                 if(j>y2) y2 = j;
24             }
25 }
26
27 void
28 build_graph()
29 {
30     int i, j, k;
31     char ch;
32     num = 0;
33     memset(adj, 0, sizeof(adj));
34     memset(in, -1, sizeof(in));
35     for(i=0; i<n; i++) {
36         for(j=0; j<m; j++) {
37             if(map[i][j]=='.' || in[map[i][j]-'A']>-1)
38                 continue;
39             in[map[i][j]-'A'] = 0;
40             ++num;
41             search(map[i][j]);
42             for(k=x1; k<=x2; k++) {
43                 ch = map[k][y1];
44                 if(ch != map[i][j])
45                     adj[map[i][j]-'A'][ch-'A'] = 1;
46             }
47             for(k=x1; k<=x2; k++) {
48                 ch = map[k][y2];
49                 if(ch != map[i][j])
50                     adj[map[i][j]-'A'][ch-'A'] = 1;
51             }
52             for(k=y1; k<=y2; k++) {
53                 ch = map[x1][k];
54                 if(ch != map[i][j])
55                     adj[map[i][j]-'A'][ch-'A'] = 1;
56             }
57             for(k=y1; k<=y2; k++) {
58                 ch = map[x2][k];
59                 if(ch != map[i][j])
60                     adj[map[i][j]-'A'][ch-'A'] = 1;
61             }
62         }
63     }
64     for(i=0; i<MAX_NUM; i++)
65         for(j=0; j<MAX_NUM; j++)
66             if(adj[i][j])
67                 ++in[j]; /* in-degree */
68 }
69
70 void
71 topological_sort(char *str, int level)
72 {
73     int i, j;
74     if(level == num) {
75         printf("%s\n", str);
76         return;
77     }
78     for(i=0; i<MAX_NUM; i++) {
79         if(in[i]==0 && !visited[i]) {
80             str[level] = 'A'+i;
81             visited[i] = 1;
82             for(j=0; j<MAX_NUM; j++)
83                 if(adj[i][j])
84                     --in[j];
85             topological_sort(str, level+1);
86             visited[i] = 0;
87             for(j=0; j<MAX_NUM; j++)
88                 if(adj[i][j])
89                     ++in[j];
90         }
91     }
92 }
93
94 int
95 main(int argc, char **argv)
96 {
97     int i;
98     char str[MAX_NUM];
99     while(scanf("%d %d", &n, &m)!=EOF) {
100         for(i=0; i<n; i++)
101             scanf("%s", map[i]);
102         build_graph();
103         memset(str, 0, sizeof(str));
104         memset(visited, 0, sizeof(visited));
105         topological_sort(str, 0);
106     }
107 }

simplyzhao 2010-09-03 16:42 发表评论