C++博客-A Za, A Za, Fighting...-随笔分类-B_搜索

PKU 3400 Dropping the stones

simplyzhao — Thu, 28 Oct 2010 03:46:00 GMT

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

思路:
这题就是个悲剧...
应该算是简单的深搜题，结果花了我一个上午
画了好几颗递归调用树也不知道为什么会出错...抓狂...
最后发现，一直出错的原因是在写代码的时候将递归函数的参数直接修改，导致后续的“同一层”的回溯调用出错，啊啊啊...

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 11
5 struct Stone {
6     int weight;
7     int cost;
8 }stones[MAX_LEN];
9 int N, D;
10 int total_cost, max_cost, hash[MAX_LEN];
11
12 void
13 dfs(char bunker, int weight_a, int cost_a, int weight_b, int cost_b)
14 {
15     int i, w, c, mark = 0;
16     if(total_cost-cost_a<=max_cost)
17         return;
18     for(i=0; i<N; i++) {
19         if(!hash[i]) {
20             mark = 1;
21             hash[i] = 1;
22             switch(bunker) {
23                 case 'A':
24                     w = weight_a+stones[i].weight;
25                     c = cost_a+stones[i].cost;
26                     if(w-weight_b <= D)
27                         dfs('A', w, c, weight_b, cost_b);
28                     else
29                         dfs('B', w, c, weight_b, cost_b);
30                     break;
31                 case 'B':
32                     w = weight_b+stones[i].weight;
33                     c = cost_b+stones[i].cost;
34                     if(w-weight_a <= D)
35                         dfs('B', weight_a, cost_a, w, c);
36                     else
37                         dfs('A', weight_a, cost_a, w, c);
38                     break;
39             }
40             hash[i] = 0;
41         }
42     }
43     if(!mark)
44         max_cost = max_cost<cost_b ? cost_b : max_cost;
45 }
46
47 int
48 main(int argc, char **argv)
49 {
50     int i;
51     while(scanf("%d %d", &N, &D) != EOF) {
52         total_cost = 0;
53         for(i=0; i<N; i++) {
54             scanf("%d %d", &stones[i].weight, &stones[i].cost);
55             total_cost += stones[i].cost;
56         }
57         max_cost = 0;
58         memset(hash, 0, sizeof(hash));
59         dfs('A', 0, 0, 0, 0);
60         printf("%d\n", max_cost);
61     }
62 }

simplyzhao 2010-10-28 11:46 发表评论

PKU 2312 Battle City (Cont.)

simplyzhao — Sat, 23 Oct 2010 12:10:00 GMT

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

思路:
在http://www.cppblog.com/Joe/archive/2010/10/23/130973.html中，参考网上代码采用了一种"新"的BFS方法来解题，该方法的一个缺点在于每个点可能多次进入队列，这也直接导致了单个点的多次扩展

其实，这题可以采用原始的BFS方法来做，只是不能再用普通的队列，而需要使用优先级队列
通过这题，使我对于宽度优先搜索有了新的认识
普通的BFS之所以能够找到最小的步数，关键在于它是单步扩展的，也就是说它首先罗列出所有在一步之内可以到达的点，然后再罗列所有在两步之内可以到达的点，类似于"1-1-1...-2-2-2...-3-3-3..."的方式
这题在扩展的时候并非都是一步，所以普通的BFS并不能找出正确的解，例如:
Y B
E T
假如我们以右、下、左、上的顺序进行扩展，那么我们将得出结果是3，而事实上只需要2

优先级队列之所以能够找出正确解，是因为它保证我们始终从最小步数的点开始扩展

代码(C++)

1 /* 0MS */
2 #include<iostream>
3 #include<cstdio>
4 #include<cstring>
5 #include<queue> /* priority queue */
6 using namespace std;
7
8 #define MAX_LEN 301
9 #define is_valid(x, y) ((x)>=0 && (x)=0 && (y)
10 char map[MAX_LEN][MAX_LEN];
11 const int dx[] = {0, 0, -1, 1};
12 const int dy[] = {-1, 1, 0, 0};
13 int M, N;
14 int you_x, you_y, target_x, target_y;
15 int visited[MAX_LEN][MAX_LEN];
16 struct Node {
17     int x, y;
18     int steps;
19     bool operator<(const Node &item) const {
20         return steps > item.steps;
21     }
22 }cur, next;
23 priority_queue<Node> states;
24
25 int
26 bfs()
27 {
28     int i;
29     memset(visited, 0, sizeof(visited));
30     while(!states.empty()) /* empty the queue */
31         states.pop();
32     next.x = you_x;
33     next.y = you_y;
34     next.steps = 0;
35     visited[you_x][you_y] = 1;
36     states.push(next);
37     while(!states.empty()) {
38         cur = states.top();
39         states.pop();
40         if(cur.x==target_x && cur.y==target_y)
41             return cur.steps;
42         for(i=0; i<4; i++) {
43             next.x = cur.x + dx[i];
44             next.y = cur.y + dy[i];
45             if(!visited[next.x][next.y]) {
46                 visited[next.x][next.y] = 1;
47                 if(map[next.x][next.y]=='E' || map[next.x][next.y]=='T') {
48                     next.steps = cur.steps+1;
49                     states.push(next);
50                 } else if(map[next.x][next.y]=='B') {
51                     next.steps = cur.steps+2;
52                     states.push(next);
53                 }
54             }
55         }
56     }
57     return -1;
58 }
59
60 int
61 main(int argc, char **argv)
62 {
63     int i, j;
64     while(scanf("%d %d", &M, &N)!=EOF && M && N) {
65         for(i=0; i<M; i++) {
66             scanf("%s", map[i]);
67             for(j=0; j<N; j++) {
68                 if(map[i][j] == 'Y') {
69                     you_x = i;
70                     you_y = j;
71                 } else if(map[i][j] == 'T') {
72                     target_x = i;
73                     target_y = j;
74                 }
75             }
76         }
77         printf("%d\n", bfs());
78     }
79 }

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

PKU 2312 Battle City

simplyzhao — Sat, 23 Oct 2010 05:33:00 GMT

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

思路:
这题纠结了...一上午都没写出来，原以为很简单的(其实，很多人都说是简单题，艾)
首先想到的是广搜，因为是求从源点到目的地的最小步数嘛，典型的BFS，结果却始终不知道如何表示每个状态以及状态间的判重
既然广搜不会，那就深搜吧，恩，很快就写出代码，结果TLE...
无奈，只好在网上找解法，发现一种相当不错的BFS代码:

队列的状态只需要保存当前位置即可，另外用数组best[][]表示目前从源点到达每个点的最小步数
在从当前点扩展的时候，只将有最小步数更新的点加入队列
这样当BFS搜索结束时，每个best[i][j]都保存了从源点到点[i][j]的最短步数
原来还有这样写BFS的方法，又学习了(*^__^*) 嘻嘻……

上述算法有点类似于求最短路径呵呵
而，事实上，这题是可以很容易转化成图论求单源最短路径的

代码:

1 /* 32MS */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_LEN 301
6 #define QUEUE_SIZE 90001
7 #define INF 0x7FFFFFFF
8 #define is_valid(x, y) ((x)>=0 && (x)=0 && (y)
9 char map[MAX_LEN][MAX_LEN];
10 const int dx[] = {0, 0, -1, 1};
11 const int dy[] = {-1, 1, 0, 0};
12 int M, N;
13 int you_x, you_y, target_x, target_y;
14 int best[MAX_LEN][MAX_LEN]; /* important, best[i][j] stores the current 'best solution' at map[i][j] */
15 struct Node {
16     int x, y;
17 } queue[QUEUE_SIZE];
18
19 int
20 bfs()
21 {
22     int i, next_x, next_y, cur, head, tail;
23     struct Node node;
24     head = -1;
25     tail = 0;
26     queue[tail].x = you_x;
27     queue[tail].y = you_y;
28     best[you_x][you_y] = 0;
29     while(head < tail) {
30         ++head;
31         cur = best[queue[head].x][queue[head].y];
32         for(i=0; i<4; i++) {
33             node.x = queue[head].x + dx[i];
34             node.y = queue[head].y + dy[i];
35             if(is_valid(node.x, node.y)) {
36                 /* excellent, only push node which can be updated in 'best' into the queue */
37                 if(map[node.x][node.y] == 'E' || map[node.x][node.y] == 'T') {
38                     if(best[node.x][node.y] > cur+1) {
39                         best[node.x][node.y] = cur+1;
40                         ++tail;
41                         queue[tail] = node;
42                     }
43                 } else if(map[node.x][node.y] == 'B') {
44                     if(best[node.x][node.y] > cur+2) {
45                         best[node.x][node.y] = cur+2;
46                         ++tail;
47                         queue[tail] = node;
48                     }
49                 }
50             }
51         }
52     }
53 }
54
55 int
56 main(int argc, char **argv)
57 {
58     int i, j;
59     while(scanf("%d %d", &M, &N)!=EOF && M && N) {
60         for(i=0; i<M; i++) {
61             scanf("%s", map[i]);
62             for(j=0; j<N; j++) {
63                 if(map[i][j] == 'Y') {
64                     you_x = i;
65                     you_y = j;
66                 } else if(map[i][j] == 'T') {
67                     target_x = i;
68                     target_y = j;
69                 }
70                 best[i][j] = INF;
71             }
72         }
73         bfs();
74         printf("%d\n", best[target_x][target_y]==INF ? -1 : best[target_x][target_y]);
75     }
76 }

simplyzhao 2010-10-23 13:33 发表评论

PKU 1010 STAMPS

simplyzhao — Thu, 21 Oct 2010 16:38:00 GMT

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

思路:
题目比较难理解，解题的话就是DFS
整整花了我一个晚上，终于AC了，(*^__^*) 嘻嘻……
虽然时间花了挺久，虽然自己的解法时间需要500+MS，虽然存在其他更优的解法，虽然......，但还是相当有成就感，完全是我自己写出来的
如果这题放在5个月之前，估计完全不知道怎么去写
在没AC之前，我一直想着自己还是原来那么菜，现在，至少可以说，比5个月之前的我已经强了
继续努力，Fighting...

代码:

  1 /* 388K 547MS */
  2 #include<stdio.h>
  3 #include<string.h>
  4 #include<stdlib.h>
  5 #define MAX_LEN 65 /* maximum number of different types of stamps */
  6 #define UPPER 4 /* maximum number of stamps */
  7 int types, stamps[MAX_LEN];
  8 int request;
  9 int maxdf, minusd, high, tie, exist, mark[MAX_LEN], ans[MAX_LEN];
10
11 int
12 compare(const void *arg1, const void *arg2)
13 {
14     return (*(int *)arg1)-(*(int *)arg2);
15 }
16
17 void
18 output()
19 {
20     int i, j;
21     if(!exist) {
22         printf("%d ---- none\n", request);
23         return;
24     }
25     printf("%d (%d): ", request, maxdf);
26     if(tie)
27         printf("tie\n");
28     else {
29         for(i=0; i<types; i++)
30             for(j=0; j<ans[i]; j++)
31                 printf("%d ", stamps[i]);
32         printf("\n");
33     }
34 }
35
36 void
37 dfs(int remain, int index, int curdf, int curusd, int curhigh)
38 {
39     int i, flag = 0;
40     if(remain == 0) {
41         if(curdf < maxdf)
42             return;
43         /* satisfy the conditions: UPDATE */
44         if((curdf>maxdf) || (curdf==maxdf&&curusd<minusd) || (curdf==maxdf&&curusd==minusd&&curhigh>high)) {
45             maxdf = curdf;
46             minusd = curusd;
47             high = curhigh;
48             exist = 1;
49             tie = 0; /* remember reset 'tie' */
50             memcpy(ans, mark, sizeof(int)*MAX_LEN); /* copy the current best to 'ans' */
51             return;
52         }
53         /* TIE occurred */
54         if(curdf==maxdf && curusd==minusd && curhigh==high) {
55             tie = 1;
56             return;
57         }
58         return;
59     }
60     /* still exist several stamps unmarked */
61     for(i=index; i<types; i++) { /* Attention: i starts from 'index', which avoid duplicates such as '1 3' and '3 1' */
62         if(!mark[i] && stamps[i]<=remain && curusd+1<=UPPER) {
63             ++mark[i];
64             flag = 1;
65             dfs(remain-stamps[i], i+1, curdf+1, curusd+1, stamps[i]);
66             --mark[i];
67         }
68     }
69     /* all available stamps have been marked */
70     if(!flag) {
71         for(i=types-1; i>=0; i--) {
72             if(stamps[i]<=remain && curusd+1<=UPPER) {
73                 ++mark[i];
74                 dfs(remain-stamps[i], 0, curdf, curusd+1, curhigh);
75                 --mark[i];
76             }
77         }
78     }
79 }
80
81 int
82 main(int argc, char **argv)
83 {
84     while(1) {
85         types = 0;
86         if(scanf("%d", &stamps[types]) == EOF)
87             break;
88         ++types;
89         while(scanf("%d", &stamps[types]) && stamps[types])
90             ++types;
91         qsort(stamps, types, sizeof(int), compare); /* ascent order */
92
93         while(scanf("%d", &request) && request) { /* each request */
94             maxdf = high = 0;
95             minusd = MAX_LEN+1;
96             exist = tie = 0;
97             memset(mark, 0, sizeof(mark));
98             dfs(request, 0, 0, 0, 0);
99             output();
100         }
101     }
102     return 0;
103 }

simplyzhao 2010-10-22 00:38 发表评论

PKU 3051 Satellite Photographs

simplyzhao — Sun, 17 Oct 2010 05:13:00 GMT

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

思路:
还是教科书式的DFS典型应用，简单题

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_W 83
5 #define MAX_H 1001
6 #define is_valid(x,y) (x>=0 && x=0 && y
7 const int dx[] = {-1, 1, 0, 0};
8 const int dy[] = {0, 0, -1, 1};
9 char photo[MAX_H][MAX_W];
10 int hash[MAX_H][MAX_W];
11 int W, H;
12
13 int
14 dfs(int x, int y)
15 {
16     int i, nx, ny, rt = 1;
17     hash[x][y] = 1;
18     for(i=0; i<4; i++) {
19         nx = x+dx[i];
20         ny = y+dy[i];
21         if(is_valid(nx, ny) && photo[nx][ny]=='*' && !hash[nx][ny])
22             rt += dfs(nx, ny);
23     }
24     return rt;
25 }
26
27 int
28 solve()
29 {
30     int i, j, tmp, value = -1;
31     for(i=0; i<H; i++)
32         for(j=0; j<W; j++) {
33             if(photo[i][j]=='*' && !hash[i][j]) {
34                 tmp = dfs(i, j);
35                 value = tmp > value ? tmp : value;
36             }
37         }
38     return value;
39 }
40
41 int
42 main(int argc, char **argv)
43 {
44     int i;
45     while(scanf("%d %d", &W, &H) != EOF) {
46         for(i=0; i<H; i++)
47             scanf("%s", photo[i]);
48         memset(hash, 0, sizeof(hash));
49         printf("%d\n", solve());
50     }
51 }

simplyzhao 2010-10-17 13:13 发表评论

PKU 1154 LETTERS

simplyzhao — Sat, 16 Oct 2010 17:19:00 GMT

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

思路:
教科书式的DFS，一次AC

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 21
5 #define is_valid(x, y) (x>=0&&x=0&&y
6 const int dx[] = {-1, 1, 0, 0};
7 const int dy[] = {0, 0, -1, 1};
8 int R, C;
9 int rt, hash[26]; /* A-Z */
10 char map[MAX_LEN][MAX_LEN];
11
12 void
13 dfs(int x, int y, int cur)
14 {
15     int i, mark, next_x, next_y;
16     mark = 0;
17     hash[map[x][y]] = 1;
18     for(i=0; i<4; i++) {
19         next_x = x + dx[i];
20         next_y = y + dy[i];
21         if(is_valid(next_x, next_y) && !hash[map[next_x][next_y]]) {
22             mark = 1;
23             hash[map[next_x][next_y]] = 1;
24             dfs(next_x, next_y, cur+1);
25             hash[map[next_x][next_y]] = 0;
26         }
27     }
28     if(!mark)
29         rt = cur>rt ? cur : rt;
30 }
31
32 int
33 main(int argc, char **argv)
34 {
35     int i;
36     while(scanf("%d %d", &R, &C) != EOF) {
37         for(i=0; i<R; i++)
38             scanf("%s", map[i]);
39         rt = -1;
40         memset(hash, 0, sizeof(hash));
41         dfs(0, 0, 1);
42         printf("%d\n", rt);
43     }
44 }

simplyzhao 2010-10-17 01:19 发表评论

USACO Packing Rectangles

simplyzhao — Wed, 13 Oct 2010 11:45:00 GMT

问题:
http://ace.delos.com/usacoprob2?a=CTINrbaHwEW&S=packrec

思路:
这题不会，考虑的时候以为任意两个矩阵至少存在相同的边才可以合并...结果完全错误

参考:
http://starforever.blog.hexun.com/2097115_d.html
http://greenmoon55.com/usaco-packing-rectangles/

另外，这题学会了在C里面使用bool类型，原来不知道呢(*^__^*) 嘻嘻……
stdbool.h头文件

代码:

  1 /*
  2 ID: simplyz2
  3 LANG: C
  4 TASK: packrec
  5 */
  6 #include<stdio.h>
  7 #include<stdbool.h>
  8 #include<stdlib.h>
  9 #include<string.h>
10 #define MAX_NUM 5
11 #define INF 0x7FFFFFFF
12 #define Max(a, b) ((a)>(b) ? (a) : (b))
13 struct Rec {
14     int h, w;
15 } rectangle[MAX_NUM], rect[MAX_NUM], ans[MAX_NUM];
16 bool used[MAX_NUM];
17 int w, h, total, area;
18
19 void
20 exchange(struct Rec *r)
21 {
22     int temp = r->h;
23     r->h = r->w;
24     r->w = temp;
25 }
26
27 void
28 judge()
29 {
30     int i, j, temp;
31     if(w > h) {
32         temp = w;
33         w = h;
34         h = temp;
35     }
36     if(w*h <= area) {
37         if(w*h == area) {
38             for(i=1; i<total; i++)
39                 if(ans[i].w == w)
40                     return;
41             for(i=1; i<total; i++)
42                 if(ans[i].w > w) {
43                     for(j=total; j>i; j--)
44                         ans[j] = ans[j-1];
45                     ans[i].w = w;
46                     ans[i].h = h;
47                     ++total;
48                     return;
49                 }
50             ans[total].w = w;
51             ans[total++].h = h;
52         } else {
53             area = w*h;
54             total = 1;
55             ans[total].w = w;
56             ans[total].h = h;
57         }
58     }
59 }
60
61 void
62 work()
63 {
64     //Case 1
65     w=rect[1].w+rect[2].w+rect[3].w+rect[4].w;
66     h=Max(rect[1].h,rect[2].h);
67     h=Max(h,rect[3].h);
68     h=Max(h,rect[4].h);
69     judge();
70
71     //Case 2
72     w=Max(rect[1].w+rect[2].w+rect[3].w,rect[4].w);
73     h=Max(rect[1].h,rect[2].h);
74     h=Max(h,rect[3].h);
75     h+=rect[4].h;
76     judge();
77
78     //Case 3
79     w=Max(rect[1].w+rect[2].w,rect[3].w)+rect[4].w;
80     h=Max(Max(rect[1].h,rect[2].h)+rect[3].h,rect[4].h);
81     judge();
82
83     //Case 4
84     w=rect[1].w+Max(rect[2].w,rect[3].w)+rect[4].w;
85     h=Max(rect[1].h,rect[4].h);
86     h=Max(h,rect[2].h+rect[3].h);
87     judge();
88
89     //Case 6
90     if (rect[3].h>=rect[2].h+rect[4].h)
91     {
92         w=Max(rect[3].w+rect[2].w,rect[3].w+rect[4].w);
93         w=Max(w,rect[1].w);
94         h=rect[1].h+rect[3].h;
95         judge();
96         return;
97     }
98     if (rect[3].h>rect[4].h)
99     {
100         w=Max(rect[1].w+rect[2].w,rect[2].w+rect[3].w);
101         w=Max(w,rect[4].w+rect[3].w);
102         h=Max(rect[1].h+rect[3].h,rect[2].h+rect[4].h);
103         judge();
104         return;
105     }
106     if (rect[3].h==rect[4].h)
107     {
108         w=Max(rect[1].w+rect[2].w,rect[3].w+rect[4].w);
109         h=Max(rect[1].h,rect[2].h)+rect[3].h;
110         judge();
111         return;
112     }
113     if (rect[3].h<rect[4].h && rect[4].h<rect[3].h+rect[1].h)
114     {
115         w=Max(rect[1].w+rect[2].w,rect[1].w+rect[4].w);
116         w=Max(w,rect[3].w+rect[4].w);
117         h=Max(rect[1].h+rect[3].h,rect[2].h+rect[4].h);
118         judge();
119         return;
120     }
121     w=Max(rect[2].w,rect[1].w+rect[4].w);
122     w=Max(w,rect[3].w+rect[4].w);
123     h=rect[4].h+rect[2].h;
124     judge();
125 }
126
127 void
128 rotate(int depth)
129 {
130     if(depth == MAX_NUM) {
131         work();
132         return;
133     }
134     rotate(depth+1);
135     exchange(rect+depth);
136     rotate(depth+1);
137 }
138
139 void
140 dfs(int depth)
141 {
142     int i;
143     if(depth == MAX_NUM) {
144         rotate(1);
145         return;
146     }
147     for(i=1; i<MAX_NUM; i++) {
148         if(!used[i]) {
149             used[i] = true;
150             rect[depth] = rectangle[i];
151             dfs(depth+1);
152             used[i] = false;
153         }
154     }
155 }
156
157 int
158 main(int argc, char **argv)
159 {
160     int i;
161     freopen("packrec.in", "r", stdin);
162     freopen("packrec.out", "w", stdout);
163     for(i=1; i<MAX_NUM; i++)
164         scanf("%d %d", &rectangle[i].w, &rectangle[i].h);
165     total = 1;
166     area = INF;
167     memset(used, 0, sizeof(used));
168     dfs(1);
169     printf("%d\n", area);
170     for(i=1; i<total; i++)
171         printf("%d %d\n", ans[i].w, ans[i].h);
172     return 0;
173 }

simplyzhao 2010-10-13 19:45 发表评论

USACO Milking Cows

simplyzhao — Mon, 27 Sep 2010 07:01:00 GMT

问题:
http://ace.delos.com/usacoprob2?a=sAaEFWx5xo1&S=milk2

思路:
如果想通了，该题还是挺简单的
首先按照开始时间进行排序，然后依次查看相邻时间段是否可以合并
针对合并后的时间段，很容易即可求出解

代码:

1 /*
2 ID: simplyz2
3 LANG: C
4 TASK: milk2
5 */
6 #include<stdio.h>
7 #include<stdlib.h>
8 #include<string.h>
9 #define MAX_LEN 5001
10 #define Max(a,b) ((a)>(b) ? (a) : (b))
11 struct Intv {
12     int begin, end;
13 } intvs[MAX_LEN], merge[MAX_LEN];
14 int num, m_num;
15
16 int
17 compare(const void *arg1, const void *arg2)
18 {
19     return (((struct Intv *)arg1)->begin - ((struct Intv *)arg2)->begin);
20 }
21
22 void
23 merge_intv()
24 {
25     int i;
26     m_num = 0;
27     qsort(intvs, num, sizeof(struct Intv), compare);
28     merge[m_num] = intvs[0];
29     for(i=1; i<num; i++) {
30         if(intvs[i].begin > merge[m_num].end)
31             merge[++m_num] = intvs[i];
32         else if(intvs[i].end > merge[m_num].end)
33             merge[m_num].end = intvs[i].end;
34     }
35 }
36
37 void
38 solve()
39 {
40     int i, rt_a, rt_b;
41     rt_a = rt_b = 0;
42     for(i=0; i<=m_num; i++) {
43         rt_a = Max(rt_a, merge[i].end - merge[i].begin);
44         if(i)
45             rt_b = Max(rt_b, merge[i].begin - merge[i-1].end);
46     }
47     printf("%d %d\n", rt_a, rt_b);
48 }
49
50 int
51 main(int argc, char **argv)
52 {
53     int i;
54     freopen("milk2.in", "r", stdin);
55     freopen("milk2.out", "w", stdout);
56     while(scanf("%d", &num) != EOF) {
57         for(i=0; i<num; i++)
58             scanf("%d %d", &intvs[i].begin, &intvs[i].end);
59         merge_intv();
60         solve();
61     }
62     return 0;
63 }

simplyzhao 2010-09-27 15:01 发表评论

PKU 1167 The Buses

simplyzhao — Wed, 08 Sep 2010 08:59:00 GMT

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

参考:
http://angels1.0.blog.163.com/blog/static/84580504200892072639857/

思路:
这题比我想象的要难好多，可以说，在看了别人AC代码之后，发现已经超越了我目前的能力
我自己的想法很简单，暴力搜索每条可能的路线，枚举每条路线的前两个点，DFS，结果始终是TLE

正确思路:
特别需要注意理解清楚题意：Buses on the same route arrive at regular intervals from 12:00 to 12:59 throughout the entire hour.
如果找出前两个点，那么这条路径上的后续点也必须存在
对输入进行预处理，找出所有可能的路径，并且按照路径中点的个数的多少降序排列（因为题意要求使得路线尽可能的少，所以首先搜索包含点个数最多的路径）
另外，还有一些简单的数学推导:
start - interval < 0 (1) [点start之前不能存在其他点]
59 - interval > start (2)
根据(1), (1)我们就可以知道start <= 29

代码中还有一处非常重要的减枝(不剪就会TLE)：
只写 r_cnt+1>=min还是会TLE

1     /* important pruning */
2         if(r_cnt+1+(left-routes[k].stops)/routes[k].stops >= min)
3             return;
4

代码(TLE):

1 void
2 dfs(int begin, int cur_routes)
3 {
4     int i, j, k, diff, cur, next=-1;
5     if(cur_routes>MAX_ROUTES || cur_routes>=min)
6         return;
7     if(begin == -1) {
8         min = cur_routes;
9         return;
10     }
11     --tm[begin];
12     cur = begin;
13     for(i=cur+1; i<MAX_T; i++) {
14         if(tm[i]) {
15             diff = i - begin;
16             /* check */
17             for(j=i; j<MAX_T; j+=diff)
18                 if(!tm[j])
19                     break;
20             if(j<MAX_T)
21                 continue;
22
23             for(j=i; tm[j]&&j<MAX_T; j+=diff)
24                 --tm[j];
25             for(k=begin+1; k<MAX_T/2; k++)
26                 if(tm[k] && next==-1)
27                     next = k;
28             dfs(next, cur_routes+1);
29             for(j=i; j<MAX_T; j+=diff)
30                 ++tm[j];
31             cur = i;
32         }
33     }
34     ++tm[begin];
35 }

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_R 910
5 #define MAX_T 60
6 #define MAX_RT 17
7 struct Route {
8     int begin;
9     int interval;
10     int stops;
11 } routes[MAX_R];
12 int cnt, left, n, min, tm[MAX_T];
13
14 int
15 compare(const void *arg1, const void *arg2)
16 {
17     return ((struct Route *)arg2)->stops - ((struct Route *)arg1)->stops;
18 }
19
20 int
21 check(int begin, int interval)
22 {
23     int i;
24     for(i=begin; i<MAX_T; i+=interval)
25         if(!tm[i])
26             return 0;
27     return 1;
28 }
29
30 void
31 init()
32 {
33     int i, j, tmp;
34     min = MAX_RT + 1;
35     cnt = 0;
36     left = n;
37     memset(tm, 0, sizeof(tm));
38     for(i=0; i<n; i++) {
39         scanf("%d", &tmp);
40         ++tm[tmp];
41     }
42     for(i=0; i<29; i++) { /* 0<=begin<=29 */
43         if(tm[i]) {
44             for(j=i+1; j<59-i; j++)
45                 if(check(i, j)) {
46                     routes[cnt].begin = i;
47                     routes[cnt].interval = j;
48                     routes[cnt++].stops = 1 + (59-i)/j;
49                 }
50         }
51     }
52     qsort(routes, cnt, sizeof(struct Route), compare); /* descend order */
53 }
54
55 void
56 dfs(int index, int r_cnt)
57 {
58     int i, k, j;
59     if(left == 0) {
60         min = min<r_cnt ? min : r_cnt;
61         return;
62     }
63     for(i=index; i<cnt&&routes[i].stops>left; i++);
64     for(k=i; k<cnt; k++) {
65         /* important pruning */
66         if(r_cnt+1+(left-routes[k].stops)/routes[k].stops >= min)
67             return;
68
69         if(check(routes[k].begin, routes[k].interval)) {
70             for(j=routes[k].begin; j<MAX_T; j+=routes[k].interval) {
71                 --tm[j];
72                 --left;
73             }
74             dfs(k, r_cnt+1);
75             for(j=routes[k].begin; j<MAX_T; j+=routes[k].interval) {
76                 ++tm[j];
77                 ++left;
78             }
79         }
80     }
81 }
82
83 int
84 main(int argc, char **argv)
85 {
86     while(scanf("%d", &n) != EOF) {
87         init();
88         dfs(0, 0);
89         printf("%d\n", min);
90     }
91 }

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

PKU 1664 放苹果

simplyzhao — Fri, 03 Sep 2010 14:48:00 GMT

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

思路:
就是根据题意进行DFS，要注意的是如何避免重复: 所放苹果数目递减
居然一会就AC了哈哈，暑假的锻炼还是有些成果的：）

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 int n, m;
5 int total;
6
7 void
8 dfs(int level, int left, int last)
9 {
10     int i, up;
11     if(level==n) {
12         if(left == 0)
13             ++total;
14         return;
15     }
16     up = left<last ? left : last;
17     for(i=up; i>=0; i--)
18         dfs(level+1, left-i, i);
19 }
20
21 int
22 main(int argc, char **argv)
23 {
24     int tests;
25     scanf("%d", &tests);
26     while(tests--) {
27         scanf("%d %d", &m, &n);
28         total = 0;
29         dfs(0, m, m);
30         printf("%d\n", total);
31     }
32 }

simplyzhao 2010-09-03 22:48 发表评论

PKU 1324 Holedox Moving

simplyzhao — Fri, 03 Sep 2010 02:05:00 GMT

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

参考:
http://hi.baidu.com/aekdycoin/blog/item/08774afbd1a29316a8d31111.html
http://clover520.blogbus.com/logs/38001465.html

思路:
用BFS求最短路径肯定是没有问题的，关键是状态如何表示
参考别人的思路，原来蛇身只需要通过上、下、左、右四个方向表示即可(两bits或4进制)，这样可以很大程度上减少空间，而且判重也就不再是个问题，只需要用三维数组表示即可
不过我自己写出来的代码却总是MLE，悲剧...(无奈，贴了别人代码过的，无耻啊)

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4
5 int kk[4][2]={1,0,0,1,0,-1,-1,0},N,M,L;
6 struct point{
7     char x,y;
8     int dis,body;
9 };
10 int bfs();
11 int main(){
12     int Cas=0;
13     while(scanf("%d%d%d",&N,&M,&L)==3){
14         if(N==0&&M==0&&L==0)break;
15         printf("Case %d: %d\n",++Cas,bfs());
16     }
17     return 0;
18 }
19 char viss[20][20][1<<14];
20 int vis(struct point* t){
21     int ans=0,i=0;
22     if(viss[t->x][t->y][t->body])return 1;
23     viss[t->x][t->y][t->body]=1;
24     return 0;
25 }
26 char map[20][20],mapt[20][20];
27 char valid(int x,int y){
28     if(x<0||x>=N||y<0||y>=M||mapt[x][y])return 0;
29     return 1;
30 }
31 struct point Q[20*20*(1<<14)];
32 int head,tail;
33 int bfs(){
34     int x,y,lx,ly,i,k,nx,ny;
35     struct point t,now;
36     memset(viss,0,sizeof(viss));
37     scanf("%d%d",&lx,&ly);
38     t.x=lx-1;t.y=ly-1;t.dis=0;t.body=0;
39     for(i=1;i<L;++i){
40         scanf("%d%d",&x,&y);
41         for(k=0;k<4;++k)if(lx+kk[k][0]==x&&ly+kk[k][1]==y)break;
42         t.body|=k<<((i-1)<<1);
43         lx=x;ly=y;
44     }
45     memset(map,0,sizeof(map));
46     scanf("%d",&k);
47     for(i=0;i<k;++i){
48         scanf("%d%d",&x,&y);
49         map[x-1][y-1]=1;
50     }
51     head=tail=0;
52     Q[tail++]=t;
53     vis(&t);
54     while(head!=tail){
55         now=Q[head++];
56         if(now.x==0&&now.y==0)return now.dis;
57
58         memcpy(mapt,map,sizeof(map));
59         mapt[x=now.x][y=now.y]=1;
60         int s=now.body;
61         for(i=1;i<L;++i,s>>=2){
62             k=s&3;
63             mapt[x=x+kk[k][0]][y=y+kk[k][1]]=1;
64         }
65
66         for(k=0;k<4;++k){
67             if(!valid(nx=now.x+kk[k][0],ny=now.y+kk[k][1]))continue;
68             t.x=nx,t.y=ny;
69             t.body=((now.body<<2)|(3-k))&((1<<((L-1)<<1))-1);
70             t.dis=now.dis+1;
71             if(!vis(&t)){
72                 Q[tail++]=t;
73             }
74         }
75     }
76     return -1;
77 }

simplyzhao 2010-09-03 10:05 发表评论

PKU 1111 Image Perimeters

simplyzhao — Thu, 19 Aug 2010 06:41:00 GMT

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

思路:
其实，这是一道简单题，关键是要看透如何求周长: 连通块每格四个方向（上下左右）如果不在连通块内（超出范围或者Empty）则周长加一
DFS或者BFS都可以解决

代码:

1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #define MAX_LEN 21
5 #define is_valid(x,y) (x>=0 && x=0 && y
6 const int dx[] = {-1, 1, 0, 0, -1, -1, 1, 1};
7 const int dy[] = {0, 0, -1, 1, -1, 1, -1, 1};
8 struct Point {
9     int x, y;
10 }queue[MAX_LEN*MAX_LEN];
11 char grid[MAX_LEN][MAX_LEN];
12 int visited[MAX_LEN][MAX_LEN];
13 int row, col, start_x, start_y;
14 int rt;
15
16 void
17 calculate(int x, int y)
18 {
19     int i, tmpx, tmpy;
20     for(i=0; i<4; i++) {
21         tmpx = x + dx[i];
22         tmpy = y + dy[i];
23         if(!is_valid(tmpx, tmpy) || grid[tmpx][tmpy]=='.')
24             ++rt;
25     }
26 }
27
28 void
29 bfs()
30 {
31     int i, head, tail, nxt_x, nxt_y;
32     head = -1;
33     tail = 0;
34     queue[tail].x = start_x-1;
35     queue[tail].y = start_y-1;
36     visited[start_x-1][start_y-1] = 1;
37     while(head < tail) {
38         ++head;
39         calculate(queue[head].x, queue[head].y);
40         for(i=0; i<8; i++) {
41             nxt_x = queue[head].x + dx[i];
42             nxt_y = queue[head].y + dy[i];
43             if(is_valid(nxt_x, nxt_y) && !visited[nxt_x][nxt_y] && grid[nxt_x][nxt_y]=='X') {
44                 ++tail;
45                 queue[tail].x = nxt_x;
46                 queue[tail].y = nxt_y;
47                 visited[nxt_x][nxt_y] = 1;
48             }
49         }
50     }
51 }
52
53 int
54 main(int argc, char **argv)
55 {
56     int i;
57     while(scanf("%d %d %d %d", &row, &col, &start_x, &start_y) != EOF) {
58         if(row==0 && col==0)
59             break;
60         for(i=0; i<row; i++)
61             scanf("%s", grid[i]);
62         rt = 0;
63         memset(visited, 0, sizeof(visited));
64         bfs();
65         printf("%d\n", rt);
66     }
67 }

simplyzhao 2010-08-19 14:41 发表评论

PKU 1020 Anniversary Cake

simplyzhao — Tue, 10 Aug 2010 11:42:00 GMT

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

思路:
原本以为是挺简单的题，结果却始终不知道怎么搜索，艾...备受打击
虽然目前对于回溯部分的代码理解起来已经没有困难，对于每次搜索都从占用最少的列开始，还是不明白为什么...

参考:
http://www.cppblog.com/RyanWang/archive/2008/10/26/65051.aspx

代码:

1 #define MAX_LEN 42
2 #define MAX_SIZE 11
3 int size, n;
4 int used[MAX_LEN], pieces[MAX_SIZE];
5 int flag;
6
7 void
8 dfs(int depth)
9 {
10     int i, j, col, min_used=MAX_LEN;
11     if(depth == n) {
12         flag = 1;
13         return;
14     }
15     for(i=1; i<=size; i++)
16         if(used[i] < min_used) {
17             min_used = used[i];
18             col = i;
19         }
20     for(i=10; i>=1; i--) {
21         if(pieces[i]>0 && used[col]+i<=size && col+i-1<=size) {
22             for(j=col; j<=col+i-1; j++)
23                 if(used[j]>min_used)
24                     break;
25             if(j>col+i-1) {
26                 --pieces[i];
27                 for(j=col; j<=col+i-1; j++)
28                     used[j] += i;
29                 dfs(depth+1);
30                 for(j=col; j<=col+i-1; j++)
31                     used[j] -= i;
32                 ++pieces[i];
33             }
34         }
35     }
36 }
37
38 int
39 main(int argc, char **argv)
40 {
41     int i, tmp, tests, sum;
42     scanf("%d", &tests);
43     while(tests--) {
44         memset(used, 0, sizeof(used));
45         memset(pieces, 0, sizeof(pieces));
46         flag = 0;
47         scanf("%d %d", &size, &n);
48         sum = 0;
49         for(i=0; i<n; i++) {
50             scanf("%d", &tmp);
51             ++pieces[tmp];
52             sum += (tmp*tmp);
53         }
54         if(sum == size*size)
55             dfs(0);
56         printf("%s\n", flag==1 ? "KHOOOOB!" : "HUTUTU!");
57     }
58 }

simplyzhao 2010-08-10 19:42 发表评论

PKU 1077 Eight (续)

simplyzhao — Sat, 07 Aug 2010 08:10:00 GMT

摘要: A*算法解题参考:http://www.cppblog.com/lo... 阅读全文

simplyzhao 2010-08-07 16:10 发表评论

PKU 1077 Eight

simplyzhao — Fri, 06 Aug 2010 08:36:00 GMT

摘要: 问题:http://acm.pku.edu.cn/JudgeOnline/problem?id=1077思路:传说中经典的经典解法有: 单向BFS，双向BFS，还有A*等启发式搜索算法今天先写了前两种方法的代码，至于启发式算法待续判重: 全排列的哈希，详见: http://www.cppblog.com/Joe/archive/2010/08/06/122410.html代码(单向BFS... 阅读全文

simplyzhao 2010-08-06 16:36 发表评论

PKU 1775 Sum of Factorials

simplyzhao — Thu, 05 Aug 2010 08:32:00 GMT

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

思路:
简单题，可以打表，可以DFS，还可以动规

代码(dfs):

1 /* Note: 10! = 3628800 */
2 #include<stdio.h>
3 #include<stdlib.h>
4 #include<string.h>
5 #define MAX_LEN 10
6 int facs[MAX_LEN];
7 int mark, n;
8
9 void
10 init()
11 {
12     int i, f = 1;
13     facs[0] = 1;
14     for(i=1; i<MAX_LEN; i++) {
15         facs[i] = f*i;
16         f = facs[i];
17     }
18 }
19
20 void
21 dfs(int depth, int sum)
22 {
23     if(sum == n) {
24         mark = 1;
25         return;
26     }
27     if(depth>=MAX_LEN || mark)
28         return;
29     dfs(depth+1, sum+facs[depth]);
30     dfs(depth+1, sum);
31 }
32
33 int
34 main(int argc, char **argv)
35 {
36     init();
37     while(scanf("%d", &n)!=EOF && n>=0) {
38         mark = 0;
39         if(n > 0)
40             dfs(0, 0);
41         printf("%s\n", mark?"YES":"NO");
42     }
43 }

代码(table, from http://blog.chinaunix.net/u3/105033/showart_2199237.html):

1 #include<iostream>
2 using namespace std;
3 bool b[1000001];
4 int sum=0;
5 int a[10]={1,1,2,6,24,120,720,5040,40320,362880};
6 void calculate(int n)
7 {
8     if(n>=10)
9         return ;
10     sum+=a[n];
11     b[sum]=true;
12     calculate(n+1);
13     sum-=a[n];
14     calculate(n+1);
15 }
16 int main()
17 {
18     memset(b,0,sizeof(b[0]));
19     calculate(0);
20     b[0]=false;
21     int n;
22     cin>>n;
23     while( n>=0)
24     {
25         if(b[n])
26             cout<<"YES"<<endl;
27         else
28             cout<<"NO"<<endl;
29         cin>>n;
30     }
31     return 0;
32 }

simplyzhao 2010-08-05 16:32 发表评论

PKU 2248 Addition Chains

simplyzhao — Thu, 05 Aug 2010 05:49:00 GMT

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

思路:
第一个想法是BFS，不过习惯性地看discuss，发现大家用的都是DFS，于是还是用DFS+减枝
这道题目的关键减枝是: num[depth+1] = num[depth]+num[i], 0<=i<=depth，另外就是从大到小的搜索顺序

另一种解法是迭代加深搜索，第一次使用，貌似就是用DFS实现BFS，不过空间需求与时间需求是两者的折衷，其模板类似于:

1 for(deep=1; 1; deep++)
2
3 {
4
5 dfs(0);
6
7 If(find = true)
8
9 break;
10
11 }

代码1:

1 #define MAX_LEN 101
2 #define INF 0x7FFFFFFF
3 int num[MAX_LEN];
4 int ans[MAX_LEN];
5 int n, min;
6
7 int
8 dfs(int depth)
9 {
10     int i, j;
11     if(depth+1 >= min)
12         return;
13     if(num[depth] == n) {
14         min = depth+1;
15         memcpy(ans, num, min*sizeof(int));
16         return;
17     }
18     for(i=depth; i>=0; i--)
19         if(num[i]+num[depth]<=n) {
20             num[depth+1] = num[i] + num[depth];
21             dfs(depth+1);
22         }
23 }
24
25 int
26 main(int argc, char **argv)
27 {
28     int i;
29     while(scanf("%d", &n)!=EOF && n!=0) {
30         min = INF;
31         num[0] = 1;
32         dfs(0);
33         for(i=0; i<min; i++)
34             printf("%d ", ans[i]);
35         printf("\n");
36     }
37     return 0;
38 }

代码2:

1 #define MAX_LEN 101
2 int num[MAX_LEN];
3 int n, find, dplimit;
4
5 void
6 dfs(int depth)
7 {
8     int i, j;
9     if(depth >= dplimit)
10         return;
11     if(num[depth] == n) {
12         if(!find) {
13             for(j=0; j<=depth; j++)
14                 printf("%d ", num[j]);
15             printf("\n");
16             find = 1;
17         }
18         return;
19     }
20     for(i=depth; i>=0; i--)
21         if(num[i]+num[depth]<=n) {
22             num[depth+1] = num[i] + num[depth];
23             dfs(depth+1);
24         }
25 }
26
27 int
28 main(int argc, char **argv)
29 {
30     while(scanf("%d", &n)!=EOF && n!=0) {
31         find = 0;
32         num[0] = 1;
33         for(dplimit=1; 1; dplimit++) {
34             dfs(0);
35             if(find)
36                 break;
37         }
38     }
39 }

simplyzhao 2010-08-05 13:49 发表评论

PKU 1475 Pushing Boxes

simplyzhao — Thu, 05 Aug 2010 04:14:00 GMT

摘要: 问题:http://acm.pku.edu.cn/JudgeOnline/problem?id=1475思路:很复杂的一题，从discuss知道可以采用嵌套的BFS来做，不过始终不知道如何下手通过这题，发现自己对于复杂问题的coding能力比较弱，不能很好的理清其中的逻辑关系，需要多多锻炼这题的关键是抓住box的每一次扩展，都对应地存在一个person的起始位置，两者需要同时记录参考:http:/... 阅读全文

simplyzhao 2010-08-05 12:14 发表评论

PKU 3411 Paid Roads

simplyzhao — Tue, 03 Aug 2010 08:47:00 GMT

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

思路:
做过几道类似的题，DFS
不过，这一道有点特殊，每条边以及每个点的访问次数并非只有一次，为了能够预付款，需要重复访问某个点或者边
这样出现的一个问题就是搜索何时结束？这里参考了网上的代码: 重复访问的原因是为了能够预先到达某个城市，而城市的总个数为N，也就是说，每个点的重复访问次数不需要超过N

另外，由于每两个点之间可能存在多条路径，因此不能使用邻接矩阵，而需要邻接表

代码

1 int N, m;
2 int min;
3 int mark[MAX_LEN];
4 struct Node {
5     int dest;
6     int adv;
7     int p, r;
8     struct Node *next;
9 };
10 struct Node *roads[MAX_LEN];
11 struct Node save[MAX_LEN];
12
13 void
14 init()
15 {
16     int i, a, b, c, p, r, cnt = 0;
17     min = INF;
18     memset(mark, 0, sizeof(mark));
19     memset(roads, 0, sizeof(roads));
20     for(i=0; i<m; i++) {
21         scanf("%d %d %d %d %d", &a, &b, &c, &p, &r);
22         save[cnt].dest = b;
23         save[cnt].adv = c;
24         save[cnt].p = p;
25         save[cnt].r = r;
26         save[cnt].next = roads[a];
27         roads[a] = save+cnt;
28         ++cnt;
29     }
30 }

simplyzhao 2010-08-03 16:47 发表评论

PKU 1190 生日蛋糕

simplyzhao — Tue, 03 Aug 2010 04:33:00 GMT

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

思路:
DFS+减枝，好题

代码:

1 /*
2  * N = R[1]^2*H[1] + R[2]^2*H[2] +  + R[M]^2*H[M]
3  * S = R[1]^2 + 2R[1]*H[1] + 2R[2]*H[2] +  + 2R[M]H[M]
4  */
5 #include<stdio.h>
6 #include<stdlib.h>
7 #include<string.h>
8 #include<math.h>
9 #define MAX_LEVEL 21
10 #define INF 0x7FFFFFFF
11 /* from top level to the i[th] level, the minimum total volumn and area */
12 int min_volumn[MAX_LEVEL], min_area[MAX_LEVEL];
13 int n, m;
14 int rt;
15
16 void
17 init()
18 {
19     int i;
20     rt = INF;
21     min_volumn[0] = min_area[0] = 0;
22     for(i=1; i<MAX_LEVEL; i++) {
23         min_volumn[i] = min_volumn[i-1] + i*i*i;
24         min_area[i] = min_area[i-1] + 2*i*i;
25     }
26 }
27
28 /* from bottom(m[th] level) to the top */
29 void
30 dfs(int level, int last_r, int last_h, int cur_volumn, int cur_area)
31 {
32     int r, h, tmp, v, a;
33     if(cur_volumn+min_volumn[level]>n || cur_area+min_area[level]>=rt)
34         return;
35     /* ADD this pruning according the volumn&area formula */
36     if(2*(n-cur_volumn)/last_r+cur_area >= rt)
37         return;
38     if(level==0) {
39         if(cur_volumn == n)
40             rt = cur_area<rt ? cur_area : rt;
41         return;
42     }
43     /* the minimal r in [level] would be level */
44     for(r=last_r-1; r>=level; r--) {
45         tmp = (int)((n-cur_volumn-min_volumn[level-1])/(double)(r*r));
46         tmp = tmp>(last_h-1) ? (last_h-1) : tmp;
47         for(h=tmp; h>=level; h--) {
48             v = r*r*h;
49             a = 2*r*h;
50             if(level == m)
51                 a += (r*r);
52             dfs(level-1, r, h, cur_volumn+v, cur_area+a);
53         }
54     }
55 }
56
57 int
58 main(int argc, char **argv)
59 {
60     int max_m_r, max_m_h;
61     while(scanf("%d %d", &n, &m) != EOF) {
62         init();
63         max_m_r = (int)(sqrt((n-min_volumn[m-1])/(double)m)) + 1;
64         max_m_h = (int)((n-min_volumn[m-1])/(double)(m*m)) + 1;
65         dfs(m, max_m_r, max_m_h, 0, 0);
66         if(rt == INF)
67             printf("0\n");
68         else
69             printf("%d\n", rt);
70     }
71 }

simplyzhao 2010-08-03 12:33 发表评论

PKU 1724 ROADS

simplyzhao — Mon, 02 Aug 2010 07:10:00 GMT

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

思路:
有点与PKU 3256类似的题
第一个想法就是深搜
第一遍代码(WA):
对于discuss里的测试数据该代码是没有问题的，可结果还是WA...

1 #define MAX_CITIES 101
2 #define INF 100000
3 int road[MAX_CITIES][MAX_CITIES];
4 int length[MAX_CITIES][MAX_CITIES];
5 int toll[MAX_CITIES][MAX_CITIES];
6 int visited[MAX_CITIES];
7 int k, n, r;
8 int min_len;
9
10 void
11 dfs(int city, int cur_len, int cur_toll)
12 {
14     int i;
15     visited[city] = 1;
16     if(cur_len>=min_len || cur_toll>k) {
17         visited[city] = 0;
18         return;
19     }
20     if(city == n) {
21         min_len = cur_len;
22         visited[city] = 0;
23         return;
24     }
25     for(i=1; i<=n; i++) {
26         if(road[city][i] && !visited[i])
27             dfs(i, cur_len+length[city][i], cur_toll+toll[city][i]);
28     }
29     visited[city] = 0;
30 }

继续翻查discuss里，发现有人说两点之间可能有多条路径...
然后看到其他人代码是使用链表来保存所有的路径，所以修改后的AC代码如下:

1 #define MAX_CITIES 101
2 #define INF 100000
3 struct Node {
4     int dest;
5     int len;
6     int toll;
7     struct Node *next;
8 };
9 struct Node roads[MAX_CITIES];
10 struct Node backup[MAX_CITIES*MAX_CITIES];
11 int visited[MAX_CITIES];
12 int k, n, r;
13 int min_len;
14
15 void
16 dfs(int c, int cur_len, int cur_toll)
17 {
18     int i;
19     struct Node *node;
20     if(cur_len>=min_len || cur_toll>k)
21         return;
22     if(c == n) {
23         min_len = cur_len;
24         return;
25     }
26     for(node=roads[c].next; node!=NULL; node=node->next) {
27         if(!visited[node->dest]) {
28             visited[node->dest] = 1;
29             dfs(node->dest, cur_len+node->len, cur_toll+node->toll);
30             visited[node->dest] = 0;
31         }
32     }
33 }
34
35 int
36 main(int argc, char **argv)
37 {
38     int i, s, d, l, t, cnt=0;
39     memset(visited, 0, sizeof(visited));
40     scanf("%d", &k);
41     scanf("%d", &n);
42     scanf("%d", &r);
43     for(i=1; i<=n; i++)
44         roads[i].next = NULL;
45     for(i=0; i<r; i++) {
46         scanf("%d %d %d %d", &s, &d, &l, &t);
47         backup[cnt].dest = d;
48         backup[cnt].len = l;
49         backup[cnt].toll = t;
50         backup[cnt].next = roads[s].next;
51         roads[s].next = backup+cnt;
52         ++cnt;
53     }
54     min_len = INF;
55     visited[1] = 1;
56     dfs(1, 0, 0);
57     if(min_len == INF)
58         printf("-1\n");
59     else
60         printf("%d\n", min_len);
61 }

simplyzhao 2010-08-02 15:10 发表评论

PKU 3373 Changing Digits

simplyzhao — Mon, 02 Aug 2010 04:46:00 GMT

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

参考:
http://blog.csdn.net/logic_nut/archive/2009/10/29/4740951.aspx
http://iaml.is-programmer.com/posts/8249.html (这个应该是SYSU的哈哈，里面有西西里)

思路:
这个题是真不会做，即使是看别人代码都看了快两天，艾...

首先要解决的问题是如何求大数的模(这里大数用字符串表示)？
我们知道对于取模运算有: (a+b)%k = ((a%k)+(b%k))%k
(ab)%k = ((a%k)(b%k))%k
对于0-9的每个数，可以将其在个、十、百、千...位时模k的结果保存到一张表中: mod_arr
这样，修改这个大数的任何一位而模k的新结果可以在O(1)时间内取得

1 char num[MAX_LEN];
2 int hash[MAX_MOD];
3 int mod_arr[MAX_LEN][10];
4 int k, len, tmp[MAX_LEN], tmp2[MAX_LEN], start_mod;
5 int head, tail;
6 struct EACH {
7     int digits[MAX_LEN];
8     int remainder;
9     int index;
10 } queue[MAX_MOD];
11
12 void
13 init()
14 {
15     int i, j;
16     len = strlen(num);
17     for(j=0; j<10; j++)
18         mod_arr[0][j] = j%k;
19     for(i=1; i<len; i++)
20         for(j=0; j<10; j++)
21             mod_arr[i][j] = (mod_arr[i-1][j]*10)%k;
22     start_mod = 0;
23     for(i=0; i<len; i++) {
24         tmp[i] = tmp2[i] = num[len-i-1]-'0';
25         start_mod += (mod_arr[i][num[len-i-1]-'0']);
26     }
27     start_mod %= k;
28     head = -1;
29     tail = 0;
30     memset(hash, 0, sizeof(hash));
31     memset(queue, 0, sizeof(queue));
32 }

第一篇参考链接里是用DFS来做的，可惜我对于其中用于记忆化搜索的remember数组始终不理解，结果TLE
更加容易理解的方案是BFS，每次扩展改变一位数字
使用BFS的问题是如何判重？参考第二篇文章(繁琐的C++语法，没认真看呵呵)，使用余数判重，其实还不是太理解

代码:

1 void
2 bfs()
3 {
4     int i, j, t, cur_rem, cur_index;
5     queue[tail].remainder = start_mod;
6     memcpy(queue[tail].digits, tmp, sizeof(int)*len);
7     queue[tail].index = len-1;
8     hash[start_mod] = 1;
9     while(head < tail) {
10         ++head;
11         cur_rem = queue[head].remainder;
12         cur_index = queue[head].index;
13         memcpy(tmp, queue[head].digits, sizeof(int)*len);
14         if(cur_rem == 0) {
15             for(i=len-1; i>=0; i--)
16                 printf("%d", tmp[i]);
17             printf("\n");
18             return;
19         }
20         /* changing digits: from least (smaller than itself) */
21         for(i=cur_index; i>=0; i--) {
22             for(j=0; j<tmp2[i]; j++) {
23                 if(i==len-1 && j==0)
24                     continue;
25                 t = cur_rem + mod_arr[i][j] - mod_arr[i][tmp2[i]] + k; /* O(1) to find the new remainder */
26                 t = t % k;
27                 tmp[i] = j;
28                 if(!hash[t]) {
29                     ++tail;
30                     queue[tail].remainder = t;
31                     queue[tail].index = i-1;
32                     memcpy(queue[tail].digits, tmp, sizeof(int)*len);
33                     hash[t] = 1;
34                 }
35             }
36             tmp[i] = tmp2[i];
37         }
38         /* changing digits: to max (greater than itself) */
39         for(i=0; i<=cur_index; i++) {
40             for(j=tmp2[i]+1; j<10; j++) {
41                 t = cur_rem + mod_arr[i][j] - mod_arr[i][tmp2[i]] + k;
42                 t = t % k;
43                 tmp[i] = j;
44                 if(!hash[t]) {
45                     ++tail;
46                     queue[tail].remainder = t;
47                     queue[tail].index = i-1;
48                     memcpy(queue[tail].digits, tmp, sizeof(int)*len);
49                     hash[t] = 1;
50                 }
51                 tmp[i] = tmp2[i];
52             }
53         }
54     }
55 }

simplyzhao 2010-08-02 12:46 发表评论

PKU 2676 Sudoku

simplyzhao — Sun, 01 Aug 2010 00:47:00 GMT

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

思路:
深度搜索
纯粹按照题意进行搜索，1532MS...额...就快TLE了呵呵
据discussion说，倒过来搜索时间会相当快

代码:

1 #define MAX_LEN 10
2 char table[MAX_LEN][MAX_LEN];
3 int flag;
4
5 int
6 is_available(int x, int y, char ch)
7 {
8     int j, k, small_x, small_y;
9     for(j=0; j<9; j++) /* row */
10         if(table[x][j]==ch)
11             return 0;
12     for(k=0; k<9; k++) /* column */
13         if(table[k][y]==ch)
14             return 0;
15     small_x = x/3;
16     small_y = y/3;
17     for(j=small_x*3; j<(small_x+1)*3; j++)
18         for(k=small_y*3; k<(small_y+1)*3; k++)
19             if(table[j][k]==ch)
20                 return 0;
21     return 1;
22 }
23
24 void
25 dfs(int x, int y)
26 {
27     int i, j, nx, ny;
28     if(flag)
29         return;
30     if(x==9){
31         if(!flag) {
32             for(j=0; j<9; j++)
33                 printf("%s\n", table[j]);
34             flag = 1;
35         }
36         return;
37     }
38     if(y==8) {
39         nx = x+1;
40         ny = 0;
41     } else {
42         nx = x;
43         ny = y+1;
44     }
45     if(table[x][y] == '0') {
46         for(i=1; i<=9; i++) {
47             if(is_available(x, y, i+'0')) {
48                 table[x][y] = i+'0';
49                 dfs(nx, ny);
50                 table[x][y] = '0';
51             }
52         }
53     } else
54         dfs(nx, ny);
55 }

更好的解题代码见:
http://blog.csdn.net/logic_nut/archive/2009/08/09/4428996.aspx

simplyzhao 2010-08-01 08:47 发表评论

PKU 2531 Network Saboteur

simplyzhao — Fri, 30 Jul 2010 08:57:00 GMT

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

思路:
更像是枚举的搜索，外加一个简单的对称性减枝，不过耗时比较久

代码:

1 #define MAX_NUM 21
2 int matrix[MAX_NUM][MAX_NUM];
3 int mark[MAX_NUM], mark_num;
4 int num, max;
5
6 int
7 calculate()
8 {
9     int i, j;
10     int sum = 0;
11     for(i=0; i<num; i++)
12         if(mark[i]) {
13             for(j=0; j<num; j++)
14                 if(!mark[j])
15                     sum += matrix[i][j];
16         }
17     return sum;
18 }
19
20 void
21 dfs(int depth)
22 {
23     int rt;
24     if(depth == num) {
25         rt = calculate();
26         max = rt>max ? rt : max;
27         return;
28     }
29     ++mark_num;
30     mark[depth] = 1; /* mark[depth]=1, put 'depth' into the category I */
31     if(mark_num <= (num>>1)) /* pruning */
32         dfs(depth+1);
33     --mark_num;
34     mark[depth] = 0;
35     dfs(depth+1); /* put 'depth' into the category II */
36 }

simplyzhao 2010-07-30 16:57 发表评论

PKU 1606 Jugs/PKU 3414 Pots

simplyzhao — Fri, 30 Jul 2010 05:45:00 GMT

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

思路:
典型的BFS
好玩的就是如何来处理输出，每个状态包含一个指向前一个状态的指针

代码:

  1 #define QUEUE_LEN 10000
  2 #define MAX_VOL 101
  3 const char ops[][12] = {
  4     "FILL(1)",
  5     "FILL(2)",
  6     "DROP(1)",
  7     "DROP(2)",
  8     "POUR(1,2)",
  9     "POUR(2,1)" };
10 int vola, volb, target;
11 int head, tail;
12 int visited[MAX_VOL][MAX_VOL];
13 struct EACH {
14     int a, b;
15     int opnum;
16     int opidx;
17     struct EACH *pre;
18 } queue[QUEUE_LEN];
19
20 #define ADD(na, nb, num, idx) ++tail; \
21     queue[tail].a = na; \
22     queue[tail].b = nb; \
23     queue[tail].opnum = num+1; \
24     queue[tail].opidx = idx; \
25     queue[tail].pre = queue+head; \
26     visited[na][nb] = 1;
27
28 void
29 output(struct EACH *item)
30 {
31     if(item == NULL)
32         return;
33     output(item->pre);
34     if(item->opidx >= 0)
35         printf("%s\n", ops[item->opidx]);
36 }
37
38 void
39 bfs()
40 {
41     int cur_a, cur_b, ta, tb, cur_opnum;
42     queue[tail].a = 0;
43     queue[tail].b = 0;
44     queue[tail].opnum = 0;
45     queue[tail].opidx = -1;
46     queue[tail].pre = NULL;
47     visited[0][0] = 1;
48     while(head < tail) {
49         ++head;
50         cur_a = queue[head].a;
51         cur_b = queue[head].b;
52         cur_opnum = queue[head].opnum;
53         if(cur_a==target || cur_b==target) {
54             printf("%d\n", cur_opnum);
55             output(queue+head);
56             return;
57         }
58         if(!visited[vola][cur_b]) { /* FILL(1) */
59             ADD(vola, cur_b, cur_opnum, 0);
60         }
61         if(!visited[cur_a][volb]) { /* FILL(2) */
62             ADD(cur_a, volb, cur_opnum, 1);
63         }
64         if(!visited[0][cur_b]) { /* DROP(1) */
65             ADD(0, cur_b, cur_opnum, 2);
66         }
67         if(!visited[cur_a][0]) { /* DROP(2) */
68             ADD(cur_a, 0, cur_opnum, 3);
69         }
70         /* POUR(1,2) */
71         if(cur_a+cur_b > volb) {
72             ta = cur_a+cur_b-volb;
73             tb = volb;
74             if(!visited[ta][tb]) {
75                 ADD(ta, tb, cur_opnum, 4);
76             }
77         } else {
78             ta = 0;
79             tb = cur_a + cur_b;
80             if(!visited[ta][tb]) {
81                 ADD(ta, tb, cur_opnum, 4);
82             }
83         }
84         /* POUR(2,1) */
85         if(cur_a+cur_b > vola) {
86             ta = vola;
87             tb = cur_a+cur_b-vola;
88             if(!visited[ta][tb]) {
89                 ADD(ta, tb, cur_opnum, 5);
90             }
91         } else {
92             ta = cur_a + cur_b;
93             tb = 0;
94             if(!visited[ta][tb]) {
95                 ADD(ta, tb, cur_opnum, 5);
96             }
97         }
98     }
99     printf("impossible\n");
100 }

simplyzhao 2010-07-30 13:45 发表评论

PKU 3083 Children of the Candy Corn

simplyzhao — Fri, 30 Jul 2010 03:01:00 GMT

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

思路:
对于求最短路径，BFS即可解决，没有什么难度

该题的难点在于如何求沿左、沿右走的问题
刚开始，完全不知道这是什么意思，无奈只能在网上看代码，总结如下:
沿左策略的一般次序: left, up, right, down
沿右策略的一般次序: right, up, left, down
求解的关键是如何根据前一个方向以及一般次序来决定目前访问上下左右四个方向的顺序，例如:
对于沿左前进策略，如果前一个方向是right，那么访问次序是up, right, down, left(与前一个方向相反的方向总是放在最后)

代码:

  1 #define MAX_LEN 42
  2 #define QUEUE_LEN 1600
  3 #define is_valid(x, y) (x>=0 && x=0 && y
  4 char maze[MAX_LEN][MAX_LEN];
  5 int visited[MAX_LEN][MAX_LEN];
  6 int row, col;
  7 int start_x, start_y;
  8 /* left, up, right, down */
  9 const int dx[] = {0, -1, 0, 1};
10 const int dy[] = {-1, 0, 1, 0};
11 /* right, up, left, down */
12 const int dx_right[] = {0, -1, 0, 1};
13 const int dy_right[] = {1, 0, -1, 0};
14 int lcount, rcount;
15 int head, tail;
16 struct EACH {
17     int x, y;
18     int mv;
19 } queue[QUEUE_LEN];
20
21
22 void
23 init()
24 {
25     int i;
26     char *p;
27     memset(visited, 0, sizeof(visited));
28     head = -1;
29     tail = 0;
30     lcount = rcount = 0;
31     scanf("%d %d", &col, &row);
32     for(i=0; i<row; i++) {
33         scanf("%s", maze[i]);
34         if((p=strchr(maze[i], 'S')) != NULL) {
35             start_x = i;
36             start_y = p-maze[i];
37         }
38     }
39 }
40
41 /*
42  * dir: previous direction
43  * switch(dir):
44  *     case(right): up right down left (order)
45  *     case(up):    left up right down
46  *     case(left):  down left up right
47  *     case(down):  right down left up
48  */
49 void
50 dfs_left(int x, int y, int dir)
51 {
52     int i, tx, ty;
53     ++lcount;
54     if(maze[x][y] == 'E') {
55         return;
56     }
57     dir = (dir+3)%4;
58     for(i=0; i<4; i++) {
59         tx = x + dx[(dir+i)%4];
60         ty = y + dy[(dir+i)%4];
61         if(is_valid(tx, ty) && maze[tx][ty]!='#') {
62             dfs_left(tx, ty, (dir+i)%4);
63             break;
64         }
65     }
66 }
67
68 void
69 dfs_right(int x, int y, int dir)
70 {
71     int i, tx, ty;
72     ++rcount;
73     if(maze[x][y] == 'E')
74         return;
75     dir = (dir+3)%4;
76     for(i=0; i<4; i++) {
77         tx = x + dx_right[(dir+i)%4];
78         ty = y + dy_right[(dir+i)%4];
79         if(is_valid(tx, ty) && maze[tx][ty]!='#') {
80             dfs_right(tx, ty, (dir+i)%4);
81             break;
82         }
83     }
84 }
85
86 int
87 bfs()
88 {
89     int i, cx, cy, tx, ty, cmv;
90     memset(visited, 0, sizeof(visited));
91     queue[tail].x = start_x;
92     queue[tail].y = start_y;
93     queue[tail].mv = 1;
94     visited[start_x][start_y] = 1;
95     while(head < tail) {
96         ++head;
97         cx = queue[head].x;
98         cy = queue[head].y;
99         cmv = queue[head].mv;
100         if(maze[cx][cy] == 'E')
101             return cmv;
102         for(i=0; i<4; i++) {
103             tx = cx + dx[i];
104             ty = cy + dy[i];
105             if(is_valid(tx, ty) && !visited[tx][ty] && maze[tx][ty]!='#') {
106                 ++tail;
107                 queue[tail].x = tx;
108                 queue[tail].y = ty;
109                 queue[tail].mv = cmv+1;
110                 visited[tx][ty] = 1;
111             }
112         }
113     }
114 }

simplyzhao 2010-07-30 11:01 发表评论

PKU 3009 Curling 2.0

simplyzhao — Thu, 29 Jul 2010 08:12:00 GMT

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

思路:
这题要求进行一个简单的游戏，判断最优步数。通常来说，这种判断最短步骤的问题可以使用广度优先搜索解决(bfs),由于题目中地图会由于游戏的进行发生变化，使用bfs会比较麻烦（需要记录地图状态），注意到题目中有一个条件：只能在10步以内完成游戏，于是我们可以考虑使用深度优先搜索（dfs）+限制步数来完成。简单的说：就是我们遍历整个搜索树寻找可能解中的最优步数，但当搜索树深度大于10时则不必继续搜索下去。

代码:

1 #define is_valid(x, y) (x>=0 && x=0 && y
2 #define INF 100000
3 #define THROW_MAX 10
4 #define MAX_LEN 21
5 int row, col, start_x, start_y;
6 int board[MAX_LEN][MAX_LEN];
7 int min;
8 const int dx[] = {0, 0, -1, 1};
9 const int dy[] = {-1, 1, 0, 0};
10
11 void
12 dfs(int depth, int x, int y)
13 {
14     int i, tx, ty;
15     if(depth>=THROW_MAX || depth>=min) /* pruning */
16         return;
17     for(i=0; i<4; i++) {
18         tx = x;
19         ty = y;
20         if(board[tx+dx[i]][ty+dy[i]] == 1) /* block immediately */
21             continue;
22         do {
23             tx += dx[i];
24             ty += dy[i];
25             if(is_valid(tx, ty) && board[tx][ty] == 3) { /* end */
26                 min = depth+1;
27                 return;
28             }
29         } while(is_valid(tx, ty) && board[tx][ty]!=1);
30         if(is_valid(tx, ty)) {
31             board[tx][ty] = 0; /* the block disappears */
32             dfs(depth+1, tx-dx[i], ty-dy[i]);
33             board[tx][ty] = 1;
34         }
35     }
36 }

simplyzhao 2010-07-29 16:12 发表评论

PKU 2488 A Knight's Journey

simplyzhao — Thu, 29 Jul 2010 04:34:00 GMT

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

思路:
十分熟悉的DFS
需要注意的一点是: 字典序，所以八个方向的搜索次序不是任意的，从左向右，从上到下，这里定义:

1 const int dx[] = {-1, 1, -2, 2, -2, 2, -1, 1};
2 const int dy[] = {-2, -2, -1, -1, 1, 1, 2, 2};

另外，我觉得只有从任何一个点出发都没法遍历，才应该输出impossible
不过，看了网上的代码，都只需要从左上角出发即可得出结论

代码:

1 #define is_valid(x, y) (x>=0 && x=0 && y
2 struct Item {
3     int x, y;
4 } path[MAX_LEN];
5 int visited[MAX_LEN][MAX_LEN];
6 int row, col, flag;
7 const int dx[] = {-1, 1, -2, 2, -2, 2, -1, 1};
8 const int dy[] = {-2, -2, -1, -1, 1, 1, 2, 2};
9
10 void
11 dfs(int depth, int x, int y)
12 {
13     int i, tx, ty;
14     visited[x][y] = 1;
15     path[depth].x = x;
16     path[depth].y = y;
17     if(depth+1 == row*col) {
18         if(!flag) {
19             flag = 1;
20             for(i=0; i<row*col; i++)
21                 printf("%c%d", 'A'+path[i].y, path[i].x+1);
22             printf("\n");
23         }
24     }
25     if(!flag) {
26         for(i=0; i<8; i++) {
27             tx = x + dx[i];
28             ty = y + dy[i];
29             if(is_valid(tx, ty) && !visited[tx][ty])
30                 dfs(depth+1, tx, ty);
31         }
32     }
33     visited[x][y] = 0;
34 }
35
36 void
37 solve()
38 {
39     int i, j;
40     memset(visited, 0, sizeof(visited));
41     flag = 0;
42     for(i=0; i<row; i++)
43         for(j=0; j<col; j++)
44             if(!flag)
45                 dfs(0, i, j);
46     if(!flag)
47         printf("impossible\n");
48 }

simplyzhao 2010-07-29 12:34 发表评论

PKU 2251 Dungeon Master

simplyzhao — Thu, 29 Jul 2010 02:01:00 GMT

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

思路:
三维的迷宫
其实，该题是典型的BFS
不过由于二维迷宫的影响以及网上题目分类的误导，开始直接DFS，结果TLE

值得小庆祝一番的是: 这是AC的第50题(*^__^*) 嘻嘻……，继续加油

代码:
TLE的DFS

1 void
2 dfs(int sl, int sr, int sc, int m)
3 {
4     if(m >= min) /* pruning */
5         return;
6     if(sl==end_l && sr==end_r && sc==end_c) {
7         min = m;
8         return;
9     }
10     int i, tl, tr, tc;
11     for(i=0; i<6; i++) {
12         tl = sl + dl[i];
13         tr = sr + dr[i];
14         tc = sc + dc[i];
15         if(is_valid(tl, tr, tc) && !visited[tl][tr][tc] && maze[tl][tr][tc]!='#') {
16             visited[tl][tr][tc] = 1;
17             dfs(tl, tr, tc, m+1);
18             visited[tl][tr][tc] = 0;
19         }
20     }
21 }

AC的BFS

1 #define MAX_SIZE 31
2 #define QUEUE_SIZE 100000
3 #define is_valid(l, r, c) (l>=0 && l=0 && r=0 && c
4 char maze[MAX_SIZE][MAX_SIZE][MAX_SIZE];
5 int visited[MAX_SIZE][MAX_SIZE][MAX_SIZE];
6 int level, row, column;
7 int begin_l, begin_r, begin_c;
8 int end_l, end_r, end_c;
9 /* direction: north, south, west, east, up, down */
10 const int dl[] = {0, 0, 0, 0, -1, 1};
11 const int dr[] = {-1, 1, 0, 0, 0, 0};
12 const int dc[] = {0, 0, -1, 1, 0, 0};
13 struct EACH {
14     int l, r, c;
15     int mins;
16 } queue[QUEUE_SIZE];
17 int head, tail;
18
19
20 void
21 init()
22 {
23     int i, j;
24     char *p;
25     memset(visited, 0, sizeof(visited));
26     memset(queue, 0, sizeof(queue));
27     head = -1;
28     tail = 0;
29     for(i=0; i<level; i++) {
30         for(j=0; j<row; j++) {
31             scanf("%s", maze[i][j]);
32             if((p=strchr(maze[i][j], 'S')) != NULL) {
33                 begin_l = i;
34                 begin_r = j;
35                 begin_c = p-maze[i][j];
36             }
37             if((p=strchr(maze[i][j], 'E')) != NULL) {
38                 end_l = i;
39                 end_r = j;
40                 end_c = p-maze[i][j];
41             }
42         }
43         getchar();
44     }
45 }
46
47 int
48 bfs()
49 {
50     int i, tl, tr, tc, cl, cr, cc, cm;
51     queue[tail].l = begin_l;
52     queue[tail].r = begin_r;
53     queue[tail].c = begin_c;
54     queue[tail].mins = 0;
55     visited[begin_l][begin_r][begin_c] = 1;
56     while(head < tail) {
57         ++head;
58         cl = queue[head].l;
59         cr = queue[head].r;
60         cc = queue[head].c;
61         cm = queue[head].mins;
62         if(cl==end_l && cr==end_r && cc==end_c)
63             return cm;
64         for(i=0; i<6; i++) {
65             tl = cl + dl[i];
66             tr = cr + dr[i];
67             tc = cc + dc[i];
68             if(is_valid(tl, tr, tc) && !visited[tl][tr][tc] && maze[tl][tr][tc]!='#') {
69                 visited[tl][tr][tc] = 1;
70                 ++tail;
71                 queue[tail].l = tl;
72                 queue[tail].r = tr;
73                 queue[tail].c = tc;
74                 queue[tail].mins = cm+1;
75             }
76         }
77     }
78     return -1;
79 }

simplyzhao 2010-07-29 10:01 发表评论

PKU 3126 Prime Path

simplyzhao — Wed, 28 Jul 2010 07:11:00 GMT

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

思路:
BFS，一次AC

代码:

1 #define QUEUE_LEN 10000
2 int from, to;
3 int head, tail;
4 struct EACH {
5     int plen;
6     int num;
7 } queue[QUEUE_LEN];
8 int hash[QUEUE_LEN];
9
10 int
11 is_prime(int num)
12 {
13     int i, up = (int)sqrt(num*1.0);
14     for(i=2; i<=up; i++)
15         if(num%i == 0)
16             return 0;
17     return 1;
18 }
19
20 int
21 bfs()
22 {
23     int cur_plen, cur_num, next_num;
24     int i, j, k, t, div;
25     queue[tail].plen = 0;
26     queue[tail].num = from;
27     hash[queue[tail].num] = 1;
28     while(head < tail) {
29         ++head;
30         cur_plen = queue[head].plen;
31         cur_num = queue[head].num;
32         if(cur_num == to)
33             return cur_plen;
34         div = 1000;
35         t = cur_num;
36         for(i=3; i>=0; i--) {
37             k = t/div;
38             for(j=0; j<=9; j++) {
39                 if(i==3 && j==0)
40                     continue;
41                 next_num = cur_num;
42                 next_num -= k*div;
43                 next_num += j*div;
44                 if(!hash[next_num] && is_prime(next_num)) {
45                     ++tail;
46                     queue[tail].plen = cur_plen + 1;
47                     queue[tail].num = next_num;
48                     hash[queue[tail].num] = 1;
49                 }
50             }
51             t = t%div;
52             div /= 10;
53         }
54     }
55     return -1;
56 }

simplyzhao 2010-07-28 15:11 发表评论