C++博客-A Za, A Za, Fighting...-随笔分类-E_数据结构

PKU 2777 Count Color

simplyzhao — Thu, 16 Sep 2010 02:57:00 GMT

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

思路:
线段树的典型题

参考:
http://blog.csdn.net/xiaofengsheng/archive/2009/03/03/3953265.aspx

代码:

  1 #include<stdio.h>
  2 #include<stdlib.h>
  3 #include<string.h>
  4 #define MAX_N 100001
  5 #define MAX_T 31
  6 #define LEFT(i) (i<<1)
  7 #define RIGHT(i) ((i<<1)+1)
  8 int L, T, O;
  9 struct Node {
10     int left, right;
11     int color;
12 };
13 struct Node nodes[MAX_N*3];
14 int rt, visited[MAX_T];
15
16 void
17 build(int begin, int end, int step)
18 {
19     int mid;
20     nodes[step].left = begin;
21     nodes[step].right = end;
22     nodes[step].color = 1;
23     if(begin == end)
24         return;
25     mid = (begin+end)>>1;
26     build(begin, mid, LEFT(step));
27     build(mid+1, end, RIGHT(step));
28 }
29
30 void
31 insert(int begin, int end, int color, int step)
32 {
33     int mid;
34     if(nodes[step].left==begin && nodes[step].right==end) {
35         nodes[step].color = color;
36         return;
37     };
38     if(nodes[step].color != -1) {
39         nodes[LEFT(step)].color = nodes[RIGHT(step)].color = nodes[step].color;
40         nodes[step].color = -1; /* mixed color */
41     }
42     mid = (nodes[step].left+nodes[step].right)>>1;
43     if(begin > mid)
44         insert(begin, end, color, RIGHT(step));
45     else if(end<=mid)
46         insert(begin, end, color, LEFT(step));
47     else {
48         insert(begin, mid, color, LEFT(step));
49         insert(mid+1, end, color, RIGHT(step));
50     }
51 }
52
53 void
54 calculate(int begin, int end, int step)
55 {
56     if(nodes[step].color != -1) {
57         if(!visited[nodes[step].color]) {
58             visited[nodes[step].color] = 1;
59             ++rt;
60         }
61         return;
62     }
63     int mid = (nodes[step].left+nodes[step].right)>>1;
64     if(mid < begin)
65         calculate(begin, end, RIGHT(step));
66     else if(mid >= end)
67         calculate(begin, end, LEFT(step));
68     else {
69         calculate(begin, mid, LEFT(step));
70         calculate(mid+1, end, RIGHT(step));
71     }
72 }
73
74 int
75 main(int argc, char **argv)
76 {
77     int i, a, b, c;
78     char ops[2];
79     while(scanf("%d %d %d", &L, &T, &O) != EOF) {
80         build(1, L, 1);
81         for(i=1; i<=O; i++) {
82             scanf("%s", ops);
83             if(ops[0] == 'C') {
84                 scanf("%d %d %d", &a, &b, &c);
85                 if(a <= b)
86                     insert(a, b, c, 1);
87                 else
88                     insert(b, a, c, 1);
89             } else if(ops[0] == 'P') {
90                 scanf("%d %d", &a, &b);
91                 rt = 0;
92                 memset(visited, 0, sizeof(visited));
93                 if(a <= b)
94                     calculate(a, b, 1);
95                 else
96                     calculate(b, a, 1);
97                 printf("%d\n", rt);
98             }
99         }
100     }
101 }

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

PKU 1988 Cube Stacking

simplyzhao — Mon, 09 Aug 2010 06:59:00 GMT

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

思路:
并查集的妙用
up[i]记录节点i到根节点的距离(有多少元素)
sum[i]记录以i作为根节点的树所包含的节点的个数
重点是在进行union与find操作时如何更新这两个数组，find操作所暗含路径压缩时up数组的更新较难理解

参考:
http://www.cppblog.com/longzxr/archive/2009/07/13/89974.html

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_NUM 30005
5 int father[MAX_NUM], up[MAX_NUM], sum[MAX_NUM];
6
7 void
8 init()
9 {
10     int i;
11     for(i=1; i<MAX_NUM; i++) {
12         father[i] = i;
13         sum[i] = 1;
14         up[i] = 0;
15     }
16 }
17
18 int
19 find(int item)
20 {
21     int tmp = father[item];
22     if(father[item] != item) {
23         father[item] = find(father[item]);
24         up[item] += up[tmp];
25     }
26     return father[item];
27 }
28
29 void
30 uunion(int top, int down)
31 {
32     int a = find(top);
33     int b = find(down);
34     if(a == b)
35         return;
36     father[b] = a;
37     up[b] = sum[a];
38     sum[a] += sum[b];
39 }
40
41 int
42 main(int argc, char **argv)
43 {
44     int p, top, down, r, cube;
45     char ch[2];
46     scanf("%d", &p);
47     init();
48     while(p--) {
49         scanf("%s", ch);
50         if(ch[0] == 'M') {
51             scanf("%d %d", &top, &down);
52             uunion(top, down);
53         } else {
54             scanf("%d", &cube);
55             r = find(cube);
56             printf("%d\n", sum[r]-up[cube]-1);
57         }
58     }
59 }

simplyzhao 2010-08-09 14:59 发表评论

PKU 2524 Ubiquitous Religions

simplyzhao — Mon, 09 Aug 2010 01:11:00 GMT

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

思路:
简单并查集，求连通分支的个数，一次AC

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_NUM 50001
5 int father[MAX_NUM];
6 int rank[MAX_NUM];
7 int total;
8
9 void
10 init(int n)
11 {
12     int i;
13     for(i=1; i<=n; i++)
14         father[i] = i;
15     memset(rank, 0, sizeof(rank));
16     total = n;
17 }
18
19 int
20 find(int item)
21 {
22     if(father[item] != item)
23         father[item] = find(father[item]);
24     return father[item];
25 }
26
27 void
28 uunion(int item1, int item2)
29 {
30     int a = find(item1);
31     int b = find(item2);
32     if(a == b)
33         return;
34     --total;
35     if(rank[a] > rank[b])
36         father[b] = a;
37     else {
38         father[a] = b;
39         if(rank[a] == rank[b])
40             ++rank[b];
41     }
42 }
43
44 int
45 main(int argc, char **argv)
46 {
47     int n, m, i, j, k, cnt=0;
48     while(scanf("%d %d", &n, &m)!=EOF) {
49         if(n==0 && m==0)
50             break;
51         init(n);
52         for(k=0; k<m; k++) {
53             scanf("%d %d", &i, &j);
54             uunion(i, j);
55         }
56         printf("Case %d: %d\n", ++cnt, total);
57     }
58 }

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

PKU 1611 The Suspects

simplyzhao — Sat, 07 Aug 2010 13:51:00 GMT

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

思路:
话说是最基础的并查集，每个分支的根节点赋予该分支节点个数的相反数，妙...

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 30001
5 int parent[MAX_LEN];
6
7 void
8 init(int size)
9 {
10     int i;
11     for(i=0; i<size; i++)
12         parent[i] = -1;
13 }
14
15 int
16 find(int item)
17 {
18     int tmp, root = item;
19     while(parent[root] >= 0)
20         root = parent[root];
21     while(item != root) {
22         tmp = parent[item];
23         parent[item] = root;
24         item = tmp;
25     }
26     return root;
27 }
28
29 void
30 uunion(int item1, int item2)
31 {
32     int root1 = find(item1);
33     int root2 = find(item2);
34     if(root1 != root2) {
35         if(parent[root1] < parent[root2]) { /* tree with 'root1' has more nodes */
36             parent[root1] += parent[root2];
37             parent[root2] = root1;
38         } else {
39             parent[root2] += parent[root1];
40             parent[root1] = root2;
41         }
42     }
43 }
44
45 int
46 main(int argc, char **argv)
47 {
48     int n, m, gp, i, j, r, stu;
49     while(scanf("%d %d", &n, &m)!=EOF) {
50         if(n==0 && m==0)
51             break;
52         init(n);
53         for(i=0; i<m; i++) {
54             scanf("%d", &gp);
55             for(j=0; j<gp; j++) {
56                 scanf("%d", &stu);
57                 if(j==0)
58                     r = stu;
59                 else
60                     uunion(r, stu);
61             }
62         }
63         printf("%d\n", -parent[find(0)]);
64     }
65 }

simplyzhao 2010-08-07 21:51 发表评论

PKU 3253 Fence Repair

simplyzhao — Sun, 04 Jul 2010 02:39:00 GMT

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

思路:
哈夫曼树（详见CLRS）
这题设计的很巧妙
理解的关键是: 将切割木板的过程反过来观察，也就是将所有最终的短木板进行拼接的过程，这其实就是哈夫曼树的构造过程
CLRS上关于哈夫曼树的构造是以优先级队列为基础的
由于倾向于用C来写，所以并没有使用C++的STL（当然，这要简单的多）
别忘了: 目的并不是要简单，而是要锻炼自己的算法及数据结构基础

以最小堆为基础的优先级队列实现:
1 #define PARENT(i) ((i-1)>>1)
2 #define LEFT_CLD(i) ((i<<1)+1)
3 #define RIGHT_CLD(i) ((i+1)<<1)
4 #define SWAP(a, b) a=a+b; b=a-b; a=a-b /* tricky */
5 int heap_size;
6
7 void
8 min_heapify(long long *heap, int i)
9 {
10     int min = i;
11     int left = LEFT_CLD(i);
12     int right = RIGHT_CLD(i);
13     if(left<heap_size && heap[min]>heap[left])
14         min = left;
15     if(right<heap_size && heap[min]>heap[right])
16         min = right;
17     if(min != i) {
18         SWAP(heap[i], heap[min]);
19         min_heapify(heap, min);
20     }
21 }
22
23 void
24 build_min_heap(long long *heap, int length)
25 {
26     int i;
27     heap_size = length;
28     for(i=(heap_size>>1)-1; i>=0; i--)
29         min_heapify(heap, i);
30 }
31
32 long long
33 extract_min(long long *heap)
34 {
35     if(heap_size < 1) {
36         fprintf(stderr, "heap underflow\n");
37         exit(1);
38     }
39     long long rt = heap[0];
40     SWAP(heap[0], heap[heap_size-1]);
41     --heap_size;
42     min_heapify(heap, 0);
43     return rt;
44 }
45
46 void
47 decrease_key(long long *heap, int i, long long new_key)
48 {
49     int c, p;
50     if(heap[i] < new_key) {
51         fprintf(stderr, "new key is larger than current key\n");
52         exit(1);
53     }
54     heap[i] = new_key;
55     c = i;
56     p = PARENT(i);
57     while(c>0 && heap[p]>heap[c]) {
58         SWAP(heap[c], heap[p]);
59         c = p;
60         p = PARENT(c);
61     }
62 }
63
64 void
65 insert(long long *heap, long long value)
66 {
67     ++heap_size;
68     heap[heap_size-1] = MAX_INT;
69     decrease_key(heap, heap_size-1, value);
70 }

哈夫曼树的构造(这里是简化版，根据题意只需要计算cost即可):
1 long long
2 huffman_tree_way(long long *heap, int length)
3 {
4     int i;
5     long long fst, snd, sum, rt=0;
6     build_min_heap(heap, length);
7     for(i=0; i<length-1; i++) {
8         fst = extract_min(heap);
9         snd = extract_min(heap);
10         sum = fst + snd;
11         rt += sum;
12         insert(heap, sum);
13     }
14     return rt;
15 }

simplyzhao 2010-07-04 10:39 发表评论

PKU 1028 Web Navigation

simplyzhao — Sun, 04 Jul 2010 01:45:00 GMT

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

思路:
这是道简单题，1次AC呵呵
最简单的做法莫过于直接用两个堆栈根据题目的description进行模拟
不过，这里，我只用了一个数组来模拟所有的动作
需要注意的一点是: FORWARD的动作只有在之前存在BACK动作的条件下才有可能有效

1 #define LEN_MAX 71
2 #define NUM_MAX 100
3 #define CMD_MAX 8
4 #define QUIT "QUIT"
5 #define FORWARD "FORWARD"
6 #define VISIT "VISIT"
7 #define BACK "BACK"
8 #define IGN "Ignored"
9 char cmd[CMD_MAX];
10 char addr[LEN_MAX];
11 char arr[NUM_MAX][LEN_MAX];
12 int cur_pos, bk_pos, fw_pos;
13 int can_fw_count;
14
15 int
16 main(int argc, char **argv)
17 {
18     cur_pos = can_fw_count = 0;
19     bk_pos = fw_pos = -1;
20     strcpy(arr[cur_pos], "http://www.acm.org/");
21     while(scanf("%s", cmd)!=EOF && strcmp(cmd, QUIT)!=0) {
22         if(strcmp(cmd, VISIT)==0) {
23             scanf("%s", addr);
24             strcpy(arr[++cur_pos], addr);
25             bk_pos = cur_pos - 1;
26             can_fw_count = 0;
27             printf("%s\n", arr[cur_pos]);
28         } else if(strcmp(cmd, BACK)==0) {
29             if(bk_pos == -1)
30                 printf("%s\n", IGN);
31             else {
32                 fw_pos = cur_pos;
33                 cur_pos = bk_pos;
34                 bk_pos = cur_pos-1;
35                 ++can_fw_count;
36                 printf("%s\n", arr[cur_pos]);
37             }
38         } else if(strcmp(cmd, FORWARD)==0) {
39             if(fw_pos == -1 || !can_fw_count)
40                 printf("%s\n", IGN);
41             else {
42                 bk_pos = cur_pos;
43                 cur_pos = fw_pos;
44                 fw_pos = cur_pos+1;
45                 --can_fw_count;
46                 printf("%s\n", arr[cur_pos]);
47             }
48         }
49     }
50     return 0;
51 }

simplyzhao 2010-07-04 09:45 发表评论