久久精品www人人爽人人,一本久久综合亚洲鲁鲁五月天亚洲欧美一区二区 ,久久久久亚洲av无码专区

hust 1017 Exact cover - DLX

y @ The Angry Teletubbies — Fri, 06 Jul 2012 09:03:00 GMT

【题意】：�l�出一个n*m的矩阵，只有0�?�Q�问能否从这个矩阵中选取x行��得每列有且仅有一�?.

【题解】：�_��覆盖�Q�DLX最基础的题目，十字链表��实��_��强大。留下DLX模板~

【代码】：

1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "algorithm"
  5 #include "vector"
  6 #include "queue"
  7 #include "cmath"
  8 #include "string"
  9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 #include "set"
13 #include "utility"
14 using namespace std;
15 typedef pair<int, int> pii;
16 #define pb push_back
17 #define mp make_pair
18 #define fi first
19 #define se second
20 #define sof(x) sizeof(x)
21 #define lc(x) (x << 1)
22 #define rc(x) (x << 1 | 1)
23 #define lowbit(x) (x & (-x))
24 #define ll long long
25
26 #define CC 1011
27 #define MM 102011
28
29 int L[MM], R[MM], U[MM], D[MM], C[MM], X[MM];
30 int H[CC], S[CC], Q[CC];
31 int size, n, m;
32
33 void remove(int c) {
34     R[L[c]] = R[c], L[R[c]] = L[c];
35     for(int i = D[c]; i != c; i = D[i])
36         for(int j = R[i]; j != i; j = R[j])
37             U[D[j]] = U[j], D[U[j]] = D[j], --S[C[j]];
38 }
39
40 void resume(int c) {
41     R[L[c]] = L[R[c]] = c;
42     for(int i = U[c]; i != c; i = U[i])
43         for(int j = L[i]; j != i ; j = L[j])
44             ++S[C[U[D[j]] = D[U[j]] = j]];
45 }
46
47 bool Dance(int k) {
48     int c = -1;
49     if(!R[0]) {
50         printf("%d", k);
51         for(int i = 0; i < k; i++) printf(" %d", X[Q[i]]);
52         puts("");
53         return true;
54     }
55     for(int tmp = CC, i = R[0]; i; i = R[i])
56         if(S[i] < tmp) tmp = S[c=i];
57     remove(c);
58     for(int i = D[c]; i != c; i = D[i]) {
59         Q[k] = i;
60         for(int j = R[i]; j != i; j = R[j]) remove(C[j]);
61         if(Dance(k + 1)) return true;
62         for(int j = L[i]; j != i; j = L[j]) resume(C[j]);
63     }
64     resume(c);
65     return false;
66 }
67
68 void Link(int r, int c) {
69     ++S[C[size] = c];
70     D[size] = D[c];
71     U[D[c]] = size;
72     U[size] = c;
73     D[c] = size;
74     if(H[r] < 0) H[r] = L[size] = R[size] = size;
75     else {
76         R[size] = R[H[r]];
77         L[R[H[r]]] = size;
78         L[size] = H[r];
79         R[H[r]] = size;
80     }
81     X[size++] = r;
82 }
83
84 int main() {
85     int num;
86     while(~scanf("%d%d", &n, &m)) {
87         for(int i = 0; i <= m; i++) {
88             S[i] = 0;
89             D[i] = U[i] = i;
90             L[i+1] = i;
91             R[i] = i + 1;
92         }
93         R[m] = 0;
94         L[0] = m;
95         size = m + 1;
96         for(int i = 1, j; i <= n; i++) {
97             H[i] = -1;//记得要先�|�行头指针�ؓ-1
98             scanf("%d", &num);
99             while(num--) {
100                 scanf("%d", &j);
101                 Link(i, j);
102             }
103         }
104         if(!Dance(0)) puts("NO");
105     }
106     return 0;
107 }
108

y @ The Angry Teletubbies 2012-07-06 17:03 发表评论

hdoj 4198 Quick out of the Harbour - 优先队列 + bfs

y @ The Angry Teletubbies — Wed, 04 Apr 2012 05:25:00 GMT

【题意】：�l�出一�q�地图，#为陆圎ͼ�.为水�Q�@为吊桥，问现在一艘船在S�q�个位置走出�q�个地图的最��时间。其中有吊桥的位�|�需要用d旉��L��吊桥升�v才能通过�?br />
【题解】：赤裸裸的优先队列+bfs�?br /> 搜到�W�一个边界点即�ؓ�{�案�?br />
【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "vector"
6 #include "queue"
7 #include "cmath"
8 #include "string"
9 #include "cctype"
10 #include "map"
11 #include "iomanip"
12 using namespace std;
13 #define pb push_back
14 #define mp make_pair
15 #define fi first
16 #define se second
17 #define lc(x) (x << 1)
18 #define rc(x) (x << 1 | 1)
19 #define lowbit(x) (x & (-x))
20 #define ll long long
21 int h, w, d;
22 int sx, sy;
23 char maz[510][510];
24 int dx[] = {0, 0, 1, -1};
25 int dy[]=  {-1, 1, 0, 0};
26 bool visit[510][510];
27 struct Node {
28     int x, y, ti;
29     Node(){}
30     Node(int _x, int _y, int _ti) {
31         x = _x, y = _y, ti = _ti;
32     }
33     bool operator<(const Node &x) const {
34         return ti > x.ti;
35     }
36 };
37
38 bool check(int x, int y) {
39     if(x >= 1 && x <= h && y >= 1 && y <= w) return true;
40     return false;
41 }
42
43 void bfs() {
44     int ans;
45     memset(visit, false, sizeof(visit));
46     priority_queue que;
47     que.push(Node(sx, sy, 1));
48     while(!que.empty()) {
49         Node now = que.top();
50         que.pop();
51         if(visit[now.x][now.y]) continue;
52         else visit[now.x][now.y] = true;
53         if((now.x == 1 || now.x == h) || (now.y == 1 || now.y == w)) {
54             ans = now.ti;
55             break;
56         }
57         for(int i = 0; i < 4; i++) {
58             int nx = now.x + dx[i], ny = now.y + dy[i];
59             if(!check(nx, ny) || maz[nx][ny] == '#' || visit[nx][ny]) continue;
60             if(maz[nx][ny] == '@') que.push(Node(nx, ny, now.ti + d + 1));
61             else que.push(Node(nx, ny, now.ti + 1));
62         }
63     }
64     cout << ans << endl;
65 }
66
67 int main() {
68     int T;
69     scanf("%d", &T);
70     while(T--) {
71         scanf("%d%d%d", &h, &w, &d);
72         for(int i = 1; i <= h; i++) {
73             scanf("%s", &maz[i][1]);
74         }
75         for(int i = 1; i <= h; i++) {
76             for(int j = 1; j <= w; j++) {
77                 if(maz[i][j] == 'S') sx = i, sy = j;
78             }
79         }
80         bfs();
81     }
82     return 0;
83 }
84

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

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

【题意】：�l�出一个��^面图�Q�问最��用多少�U�颜色来染色能够使得图中盔R��l�点颜色不同�?br />
【题解】：�q�面图染�Ԍ��四色定理�?br /> 直接dfs卛_��?br />
【代码】：

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

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

sgu 536 Berland Chess - 状态压�~?+ bfs

y @ The Angry Teletubbies — Tue, 08 Nov 2011 06:07:00 GMT

【题意】：�l�出一个n*m的国际象��棋�?(1 ≤ n, m ≤ 15)�Q�棋盘里面只有四�U�棋子�?br /> * 白色的皇可以向�Q意周围八格移动一�?br /> R 黑色的�R 可以横着或竖着�U�d��L��?br /> K 黑色的马 �U�d��“�?#8221;�?br /> B 黑色的象可以斜着��C�Q意格
已知��盘最多有15个棋子，有且只有一个白色的皇，且黑��在吃不到皇的情况下是不会移动的�?br /> 问，在不被吃的情况下�Q�皇最��用多少步可以吃光所有的黑棋�?br />
【题解】：考虑到最多只�?5个棋子，可以�q�行状态压�~�的bfs。这里有个trick��是�Q�象和�R可能会被其他��子挡着而吃不到皇�?br />
【代码】：

  1 #include "iostream"
  2 #include "cstdio"
  3 #include "cstring"
  4 #include "queue"
  5 using namespace std;
  6 int r, c, sx, sy;
  7 int cnt;
  8 char maz[20][20];
  9 int maze[20][20];
10 bool visit[20][20][40000];
11 int dir[][2] = {0, 1, 1, 0, -1, 0, 0, -1, 1, -1, -1, 1, 1, 1, -1, -1};
12 int kdir[][2] = {-2, -1, -2, 1, 2, 1, 2, -1, 1, 2, 1, -2, -1, 2, -1, -2};
13 int bdir[][2] = {1, -1, 1, 1, -1, -1, -1, 1};
14 int rdir[][2] = {0, 1, 1, 0, -1, 0, 0, -1};
15 struct Node {
16     int x, y, ti, mask;
17     Node(){}
18     Node(int _x, int _y, int _ti, int _mask) {
19         x = _x, y = _y, ti = _ti, mask = _mask;
20     }
21 };
22
23 struct Piece {
24     int x, y, type;
25     Piece(){}
26     Piece(int _x, int _y, int _type) {
27         x = _x, y = _y, type = _type;
28     }
29 }p[20];
30
31 bool check(int x, int y) {
32     if(x >= 1 && x <= r && y >= 1 && y <= c) return true;
33     return false;
34 }
35
36 bool IsEat(int x, int y, int mask) {
37     //Knight
38     for(int i = 0; i < 8; i++) {
39         int xx = x + kdir[i][0], yy = y + kdir[i][1];
40         int tmp = maze[xx][yy];
41         if(!check(xx, yy)) continue;
42         if(tmp >= 0 && !(mask & (1 << tmp)) && p[tmp].type == 0) return true;
43     }
44     //Bishop
45     for(int i = 0; i < 4; i++) {
46         int xx = x + bdir[i][0], yy = y + bdir[i][1];
47         int tmp = maze[xx][yy];
48         while(check(xx, yy)) {
49             if(tmp >= 0 && !(mask & (1 << tmp))) {
50                 if(p[tmp].type == 1) return true;
51                 else break;
52             } else xx += bdir[i][0], yy += bdir[i][1], tmp = maze[xx][yy];
53         }
54     }
55     //Rook
56     for(int i = 0; i < 4; i++) {
57         int xx = x + rdir[i][0], yy = y + rdir[i][1];
58         int tmp = maze[xx][yy];
59         while(check(xx, yy)) {
60             if(tmp >= 0 && !(mask & (1 << tmp))) {
61                 if(p[tmp].type == 2) return true;
62                 else break;
63             } else xx += rdir[i][0], yy += rdir[i][1], tmp = maze[xx][yy];
64         }
65     }
66     return false;
67 }
68
69 int bfs() {
70     queue<Node> que;
71     memset(visit, false, sizeof(visit));
72     visit[sx][sy][0] = true;
73     que.push(Node(sx, sy, 0, 0));
74     while(!que.empty()) {
75         Node now = que.front();
76         que.pop();
77         if(now.mask == (1 << cnt) - 1) return now.ti;
78         for(int i = 0; i < 8; i++) {
79             int nx = now.x + dir[i][0], ny = now.y + dir[i][1], mask = now.mask;
80             if(!check(nx, ny)) continue;
81             int tmp = maze[nx][ny];
82             if(tmp >= 0) mask |= (1 << tmp);
83             if(visit[nx][ny][mask]) continue;
84             if(IsEat(nx, ny, mask)) continue;
85             que.push(Node(nx, ny, now.ti + 1, mask));
86             visit[nx][ny][mask] = true;
87         }
88     }
89     return -1;
90 }
91
92 int main() {
93     while(~scanf("%d%d", &r, &c)) {
94         cnt = 0;
95         memset(maze, -1, sizeof(maze));
96         for(int i = 1; i <= r; i++) scanf("%s", &maz[i][1]);
97         for(int i = 1; i <= r; i++) {
98             for(int j = 1; j <= c; j++) {
99                 if(maz[i][j] == '.') continue;
100                 if(maz[i][j] == '*') sx = i, sy = j;
101                 else if(maz[i][j] == 'K') {
102                     maze[i][j] = cnt, p[cnt++] = Piece(i, j, 0);
103                 } else if(maz[i][j] == 'B') {
104                     maze[i][j] = cnt, p[cnt++] = Piece(i, j, 1);
105                 } else maze[i][j] = cnt, p[cnt++] = Piece(i, j, 2);
106             }
107         }
108         int ans = bfs();
109         cout << ans << endl;
110     }
111     return 0;
112 }

y @ The Angry Teletubbies 2011-11-08 14:07 发表评论

SWERC 2010 F Jumping monkey - 状态压�~?+ bfs

y @ The Angry Teletubbies — Fri, 28 Oct 2011 17:17:00 GMT

【题意】：你是一个猎人，�q�里有n(n <= 21)��|��和一只猴子，你想猎杀�q�只猴子�Q�但你不知道�q�只猴子具体在哪��|��上。每一�ơ你可以随便��击一��|��Q�如果猴子在�q�课树上��׃��被杀掉。如果猴子不在这��|��上，他一定会跛_��与当前所处的树相�ȝ��其他树。给出树与树之间的相��d��p�，问猎杀�q�只猴子的最��开枪数是多��，�q�输出射�ȝ��Ҏ��Q�如果存在多�l�相�{�开枪数的方案则输出字典序最��的那一�l��?br />
【题解】：非常好的搜烦题！刚开始以为是个博弈的东西�Q�后来一直推不到最优决�{�，意识到数据有�q�么��，应该可以搜烦�q�去�?br /> 因�ؓn��于�{�于21�Q�可以采用状态压�~�。对于猴子可能在的某些棵树标��Cؓ1�Q�否则标��Cؓ0�Q�最�l�状态�ؓ�?�Q�即0.
猴子从当前的树蟩到相�ȝ��树这个要先预处理�Q�以后每�ơ可以用O(n)的时间复杂度转移状态�?br /> 不可能存在猴子的树是不用��的�Q�这里可以剪枝；如果m > n - 1卛_��p�M��存在环则一定无解�?br />
【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "queue"
5 #include "string"
6 using namespace std;
7 int n, m;
8 bool visit[1<<22];
9 int edge[22];
10 string ans;
11 struct Node {
12     int mask;
13     string path;
14     Node(){}
15     Node(int _mask, string _path) {
16         mask = _mask, path = _path;
17     }
18 };
19
20 bool bfs() {
21     queue<Node> que;
22     memset(visit, false, sizeof(visit));
23     que.push(Node((1 << n) - 1, ""));
24     visit[(1<<n)-1] = true;
25     while(!que.empty()) {
26         Node now = que.front();
27         que.pop();
28         for(int i = 0; i < n; i++) {
29             if(now.mask & (1 << i)) {
30                 int mask = now.mask ^ (1 << i);
31                 int newmask = 0;
32                 for(int j = 0; j < n; j++)
33                     if(mask & (1 << j)) newmask |= edge[j];
34                 if(visit[newmask]) continue;
35                 visit[newmask] = true;
36                 char ch = i + '0';
37                 string tmp = now.path + ch;
38                 if(newmask == 0) {
39                     ans = tmp;
40                     return true;
41                 }
42                 que.push(Node(newmask, tmp));
43             }
44         }
45     }
46     return false;
47 }
48
49 void solve() {
50     if((m > n - 1) || !bfs()) printf("Impossible\n");
51     else {
52         printf("%d:", ans.length());
53         for(int i = 0; i < ans.length(); i++) printf(" %d", ans[i] - '0');
54         printf("\n");
55     }
56     return;
57 }
58
59 int main() {
60     while(~scanf("%d%d", &n, &m)) {
61         if(!n && !m) break;
62         memset(edge, 0, sizeof(edge));
63         for(int i = 0; i < m; i++) {
64             int u, v;
65             scanf("%d%d", &u, &v);
66             edge[u] |= (1 << v), edge[v] |= (1 << u);
67         }
68         solve();
69     }
70     return 0;
71 }

y @ The Angry Teletubbies 2011-10-29 01:17 发表评论

hdoj 1043 Eight - IDA_star

y @ The Angry Teletubbies — Sun, 18 Sep 2011 02:18:00 GMT

【题意】：八数码问�?br />
【题解】：IDA*�Q�用每个数字到目标位�|�的哈曼��\长来做估价函敎ͼ�奇偶判断有没有可行解�?br />
【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "cstdlib"
5 #include "queue"
6 using namespace std;
7 #define SIZE 3
8 const int dx[] = {-1, 0, 0, 1};
9 const int dy[] = {0, -1, 1, 0};
10 char op[] = {'u', 'l', 'r', 'd'};
11 int goal_state[10][2] = {{0,0}, {1,1}, {1,2}, {1,3}, {2,1}, {2,2}, {2,3}, {3,1}, {3,2}, {3,3}};
12 int bound;
13 char a[10];
14 bool flag;
15 char solution[1000];
16
17 struct Eight {
18     char board[4][4];
19     int x, y;
20 };
21
22 int h(char board[][4]) {
23     int cost = 0;
24     for(int i = 1; i <= SIZE; i++)
25         for(int j = 1; j <= SIZE; j++)
26             if(board[i][j]) cost += abs(i - goal_state[board[i][j]][0]) + abs(j - goal_state[board[i][j]][1]);
27     return cost;
28 }
29
30 bool solvable() {
31     int cnt = 0;
32     for(int i = 1; i <= 9; i++)
33         for(int j = 1; j < i; j++)
34             if(a[j] < a[i] && a[j]) cnt++;
35     if(cnt & 1) return false;
36     return true;
37 }
38
39 bool check(int x, int y) {
40     if(x >= 1 && x <= SIZE && y >= 1 && y <= SIZE) return true;
41     return false;
42 }
43
44 bool dfs(Eight now, int dv, char pre) {
45     if(h(now.board) == 0) {
46         solution[dv] = 0;
47         return true;
48     }
49     for(int i = 0; i < 4; i++) {
50         if(i + pre == 3) continue;//与上一步相反的�U�d��
51         Eight next = now;
52         next.x += dx[i], next.y += dy[i];
53         if(check(next.x, next.y)) {
54             solution[dv] = op[i];
55             swap(next.board[next.x][next.y], next.board[now.x][now.y]);
56             if(h(next.board) + dv >= bound) continue;
57             if(dfs(next, dv + 1, i)) return true;
58         }
59     }
60     return false;
61 }
62
63 void IDA_star(Eight st) {
64     bound = h(st.board);
65     for(bound = h(st.board); !dfs(st, 0, -10); bound++);
66     puts(solution);
67 }
68
69 int main() {
70     int sx, sy;
71     char c[2];
72     while(1) {
73         Eight st;
74         for(int i = 1; i <= SIZE; i++) {
75             for(int j = 1; j <= SIZE; j++) {
76                 if(scanf("%s", c) == EOF) return 0;
77                 if(c[0] == 'x') {
78                     st.board[i][j] = 0;
79                     st.x = i, st.y = j;
80                 } else st.board[i][j] = c[0] - '0';
81                 a[(i - 1) * SIZE + j] = st.board[i][j];
82             }
83         }
84         if(solvable()) IDA_star(st);
85         else printf("unsolvable\n");
86     }
87     return 0;
88 }
89

y @ The Angry Teletubbies 2011-09-18 10:18 发表评论

poj 1011/uva 307 Sticks - dfs回溯 + 剪枝

y @ The Angry Teletubbies — Wed, 07 Sep 2011 17:18:00 GMT

【题意】：乔治拿来一�l�等长的木棒�Q�将它们随机地砍断，使得每一节木��的长度都不��过50个长度单位。然后他又想把这些木��恢复到��截前的状态，但忘��C��初始时有多少木棒以及木棒的初始长度。请你设计一个程序，帮助乔治计算木棒的可能最��长度。每一节木��的长度都用大于零的整数表示�?br />
【随�W�】：�q�道题很早之前就�q�了�Q�这几天看回之前的代码，觉得以前的代码写得太烂了�Q�而且那个代码风格也不好看�Q�于是决定再重写一边，��Z��把uva的也�q�了。这�ơ重写比之前的代码加多了一个重要的剪枝�Q�最后在uva上以0.2s�q�了�?br />
【题解】：不得不说�Q�这道题出得非常好，特别是uva那里的大数据�Q�poj的数据太水了�Q�，对于剪枝能力要求很高。下面说下几个重要的剪枝�Q?br />1.把所有木��的长度从大到小排列�Q�组合木��时优先使用长的木棍�Q�这样可以加快组合速度�Q��ƈ且对后面的剪枝有帮助�?br />2.木棒的长度一定是大于�{�于最长木��的长度�q�且��于�{�于所有木��长度的和，�q�个很容易证明�?br />3.木棒的长度一定是所有木��长度的和的�U�数�Q�这个也很容易证明�?br />4.在某一个木��的�l�合�q�程中，对于当前的木��stick[i]�Q�如果stick[i-1]没有被组合�ƈ且stick[i] == stick[i-1]�Q�那么不用考虑stick[i]�Q�显然stick[i]最�l�也不会被组合�?br />5.如果此次是在��试�W�i个木��的�W�一�D�，假设stick[j]为当前可以被使用的最长的木棍�Q�如果此�ơ组合失败，直接退出搜索，即退回到对第i-1个木��的搜烦。试惻I��p�|说明现在使用stick[j]是不可行的，那么以后无论什么时候��用stick[j]都是不可行的�Q�因��Z��后再处理stick[j]时可使用的木��一定是当前可��用的木棍的子集，在更多木��选择的情况下都不能组合成功，那么�Q�在更少木棍选择的情况下一定不能组合成功�?br />
【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "algorithm"
5 #include "functional"
6 using namespace std;
7 #define maxn 65
8 int n, sum, goal;
9 int stick[maxn];
10 bool visit[maxn];
11
12 bool cmp(const int &a, const int &b) {
13     return a > b;
14 }
15
16 bool dfs(int now, int index, int cnt) {
17     if(goal * cnt == sum) return true;
18     for(int i = index; i < n; i++) {
19         if(visit[i] || (i && !visit[i-1] && stick[i] == stick[i-1])) continue;
20         if(now + stick[i] == goal) {
21             visit[i] = true;
22             if(dfs(0, 0, cnt + 1)) return true;
23             visit[i] = false;
24             return false;
25         } else if(now + stick[i] < goal) {
26             visit[i] = true;
27             if(dfs(now + stick[i], i + 1, cnt)) return true;
28             visit[i] = false;
29             if(now == 0) return false;
30         }
31     }
32     return false;
33 }
34
35 int solve() {
36     sort(stick, stick + n, cmp);
37     for(goal = stick[0]; goal < sum; goal++) {
38         if(sum % goal != 0) continue;
39         memset(visit, false, sizeof(visit));
40         if(dfs(0, 0, 0)) break;
41     }
42     return goal;
43 }
44
45 int main() {
46     while(~scanf("%d", &n)) {
47         if(!n) break;
48         sum = 0;
49         for(int i = 0; i < n; i++) {
50             scanf("%d", &stick[i]);
51             sum += stick[i];
52         }
53         printf("%d\n", solve());
54     }
55     return 0;
56 }

y @ The Angry Teletubbies 2011-09-08 01:18 发表评论

y @ The Angry Teletubbies — Fri, 26 Aug 2011 12:13:00 GMT

【题意】：地图中有K�U�物�? 没有攉��资源�Ӟ��每走一步用能量1�Q�挖掘和攉��资源 i 需要能量Ai �Q�收集了资源 i �? 每走一步，消耗能量需要加Bi。问最后收集完K�U�物品�ƈ且回到�v点的最��消耗�?br />
【题解】：采用了优先队�?状态压�~�bfs�Q�这里要预处理好携带了状态s的代价cost[s]�Q�之后的bfs该怎么做就怎么做。这里用优先队列有个好处�Q�这样就保证每次出队的都是最优的点，相比用一个数�l�来记录�Q�更省空��_��q�且代码量也��了�?br />
【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "queue"
5 using namespace std;
6 char maz[25][25];
7 int k, p, r, c;
8 int a[15], b[15], cost[1<<11];
9 const int dx[] = {0, 1, 0, -1};
10 const int dy[] = {-1, 0, 1, 0};
11 int sx, sy;
12 bool visit[25][25][1<<11];
13
14 struct pos {
15     int x, y, cost, collect;
16     pos() {}//构造函�?/span>
17     pos(int a, int b, int c, int d) {
18         x = a, y = b, cost = c, collect = d;
19     }
20     bool operator< (const pos &a) const {
21         return cost > a.cost;
22     }
23 };
24
25 bool check(int x, int y) {
26     return x >= 0 && x < r && y >= 0 && y < c;
27 }
28
29 int bfs() {
30     priority_queue<pos> que;
31     memset(visit, false, sizeof(visit));
32     que.push(pos(sx, sy, 0, 0));
33     visit[sx][sy][0] = true;
34     while(!que.empty()) {
35         pos now = que.top();
36         que.pop();
37         int x = now.x, y = now.y, collect = now.collect, ncost = now.cost + cost[collect] + 1;
38         if(ncost > p) continue;
39         for(int i = 0; i < 4; i++) {
40             int nx = x + dx[i], ny = y + dy[i];
41             if(!check(nx, ny) || maz[nx][ny] == '#' || visit[nx][ny][collect]) continue;
42             if(nx == sx && ny == sy) {
43                 if(collect == (1 << k) - 1) return ncost;
44                 continue;
45             }
46             if(maz[nx][ny] <= 'Z' && maz[nx][ny] >= 'A') {
47                 int t = maz[nx][ny] - 'A';
48                 if((collect & (1 << t)) == 0) {
49                     que.push(pos(nx, ny, ncost + a[t], collect | (1<<t)));
50                     visit[nx][ny][collect|(1<<t)] = true;
51                 }
52             }
53             que.push(pos(nx, ny, ncost, collect));
54             visit[nx][ny][collect] = true;
55         }
56     }
57     return -1;
58 }
59
60 int main() {
61     int T;
62     scanf("%d", &T);
63     while(T--) {
64         scanf("%d%d%d%d\n", &r, &c, &k, &p);
65         for(int i = 0; i < r; i++) {
66             for(int j = 0; j <= c; j++) {
67                 scanf("%c", &maz[i][j]);
68                 if(maz[i][j] == '*') sx = i, sy = j;
69             }
70         }
71         for(int i = 0; i < k; i++) scanf("%d%d", &a[i], &b[i]);
72         memset(cost, 0, sizeof(cost));
73         for(int t = 0; t < (1 << k); t++)
74             for(int j = 0; j < k; j++)
75                 if(t & (1 << j)) cost[t] += b[j];
76         int ans = bfs();
77         if(ans == -1) printf("Impossible\n");
78         else printf("%d\n", ans);
79     }
80     return 0;
81 }

y @ The Angry Teletubbies 2011-08-26 20:13 发表评论

zoj 3446 Doraemon's Battle - bfs

y @ The Angry Teletubbies — Wed, 17 Aug 2011 07:01:00 GMT

【题意】：Doraemon正在与m个敌人战斗，Doraemon有两�U�属性HP和SP�Q�经常打机的朋友都知道是什么喇�Q�HP是血量，SP是魔法量�Q�。如果Doraemon的HP��于或等�?的话�Q�那么就意味着战斗��p�|。HP和SP分别有一个上限LH、LS�Q�每个回合中Doraemon和敌��行动（Doraemon��L��先行动）�Q�在每个回合中，Doraemon能选择下列4�U�操作中的其中一�U�：
      1.杀��M��个敌人�ƈ使SP回复1�?nbsp;
      2.恢复floor(0.2*LH�Q�的血�?nbsp;
      3.如果当前SP大于0�Q�可以发动技能杀死D[SP]个敌人，�q�且SP清零
      4.待机�Q�其实就是什么都不做
每次在Doraemon行动完后�Q�每个敌人可以消耗Doraemon一滴血。在每个回合的最后，Doraemon能够恢复[当前敌�h�?3]的SP。一开始Doraemon处于满血�Q�零SP的状态，问Doraemon杀��L��有敌人的最��回合数是多��？如果Doraemon不可能战胜，误��?#8220;HELP!”�?br />
【题解】：在比赛中看到�q�道题觉得是博弈�Q�然后YY了一轮之后没扑ֈ��M��规律。后来发现这是一道搜索题�Q�一个单�U�的bfs可解�Q�而且bfs能满��x��的回合数。这道题�l�节的地�Ҏ��较多�Q?br />      1.当前的HP和SP在�Q何时候都不能��过上限LH、LS
      2.每回合结束前都要恢复[当前敌�h�?3]的SP
      3.每回合��L��Doraemon先行动，然后轮到敌�h行动
      4.在��用完技能后SP要变�?�Q��ƈ�?[当前敌�h�?- D[SP]] 可能出现负数
      5.[��优化]�W�四�U�操作待机显然是没用的，如果选择待机的话�q�不如选择加血�Q�这里可以剪掉�?br />
【代码】：

1 #include "iostream"
2 #include "cstdio"
3 #include "cstring"
4 #include "queue"
5 #include "cmath"
6 using namespace std;
7 #define MAX 105
8 int lh, ls, n;
9 int d[MAX];
10 int visit[255][105][45];
11 int add;
12
13 struct st {
14     int hp, sp, cnt;
15     void init(int a, int b, int c) {
16         if(a > lh) a = lh;
17         if(b > ls) b = ls;
18         hp = a, sp = b, cnt = c;
19     }
20 } start;
21
22 int bfs() {
23     queue<st> que;
24     que.push(start);
25     visit[start.hp][start.sp][start.cnt] = 1;
26     while (!que.empty()) {
27         st now = que.front(), next;
28         que.pop();
29         //�W�一�U�操�?/span>
30         next.init(now.hp - (now.cnt - 1), now.sp + 1 + (now.cnt - 1) % 3, (now.cnt - 1));
31         if (next.cnt <= 0) return visit[now.hp][now.sp][now.cnt];
32         if (next.hp > 0 && !visit[next.hp][next.sp][next.cnt]) {
33             visit[next.hp][next.sp][next.cnt] = visit[now.hp][now.sp][now.cnt] + 1;
34             que.push(next);
35         }
36         //�W�二�U�操�?/span>
37         next.init(now.hp + add - now.cnt, now.sp + now.cnt % 3, now.cnt);
38         if (next.hp > 0 && !visit[next.hp][next.sp][next.cnt]) {
39             visit[next.hp][next.sp][next.cnt] = visit[now.hp][now.sp][now.cnt] + 1;
40             que.push(next);
41         }
42         //�W�三�U�操�?/span>
43         if (now.sp > 0) {
44             if(now.cnt - d[now.sp] <= 0) return visit[now.hp][now.sp][now.cnt];
45             next.init(now.hp - (now.cnt - d[now.sp]), (now.cnt - d[now.sp]) % 3, (now.cnt - d[now.sp]));
46             if (next.hp > 0 && !visit[next.hp][next.sp][next.cnt]) {
47                 visit[next.hp][next.sp][next.cnt] = visit[now.hp][now.sp][now.cnt] + 1;
48                 que.push(next);
49             }
50         }
51     }
52     return -1;
53 }
54
55 void init() {
56     for (int i = 0; i < 255; i++)
57         for (int j = 0; j < 105; j++)
58             for (int k = 0; k < 45; k++)
59                 visit[i][j][k] = 0;
60     add = (int) floor(0.2 * lh);
61 }
62
63 int main() {
64     while (~scanf("%d%d%d", &lh, &ls, &n)) {
65         for (int i = 1; i <= ls; i++) scanf("%d", &d[i]);
66         start.init(lh, 0, n);
67         init();
68         int ans = bfs();
69         if (ans == -1) printf("HELP!\n");
70         else printf("%d\n", ans);
71     }
72     return 0;
73 }

y @ The Angry Teletubbies 2011-08-17 15:01 发表评论

zoj 3291 Never End - bfs

y @ The Angry Teletubbies — Mon, 15 Aug 2011 14:37:00 GMT

【题意】：在一个迷宫里�Q�有一个�h�Q�还有一个出口。这里有四种操作�Q?.人向左走 2.人向双�� 3.把整个迷宫向左�{ 4.把整个迷宫向双��{。每操作一�ơ都会花费一个时间单位。问人最后能否走��宫？如果能，输出最短的旉��?br />
【题解】：看到最短时��_��我们很容易就惛_��bfs。这题与�q�x��的迷宫问题有一个不同的地方��是�Q��^旉��目所�l�的�q�宫是俯视图�Q�而这里是主视图，考虑到这一点，我们��p��把重力加入我们的思考范围。简单点来说��是�Q�如果当前这个�h向左��C��一步，而那个位�|�是没有站块的，那么人就会向下跌�Q�直到有东西��住为止。实际操作的时候可以固定迷宫不动，而是通过人来旋�{�Q�这昄��是可以的。一开始我们可以预处理一下对于每个格转动之后��Z��跌在哪里�Q�这��h��们以后就可以用O�Q?�Q�的旉��来找��C��一个状态。其余的操作跟普通bfs一栗��?br />
【代码】：

1 #include "iostream"
2 #include "queue"
3 #include "cstdio"
4 using namespace std;
5 #define MAX 505
6 struct node {
7     int x, y, dir;
8     void init(int a, int b, int c) {
9         x = a, y = b, dir = c;
10     }
11 }rot[MAX][MAX][4], s;
12 int n, m;
13 int ti[MAX][MAX][4];
14 char maz[MAX][MAX];
15 const int dx[4] = {1, 0, -1, 0};
16 const int dy[4] = {0, 1, 0, -1};
17
18 bool check(int i, int j) {
19     if(i >= 1 && i <= n && j >= 1 && j <= m) return true;
20     return false;
21 }
22
23 int bfs() {
24     queue<node> que;
25     que.push(s);
26     ti[s.x][s.y][s.dir] = 1;
27     while(!que.empty()) {
28         node now = que.front(), next;
29         que.pop();
30         if(maz[now.x][now.y] == 'E') return ti[now.x][now.y][now.dir];
31         for(int i = 0; i < 4; i++) {
32             if((now.dir % 2 == 0 && i % 2 != 0) || (now.dir % 2 != 0 && i % 2 == 0)) {
33                 if(maz[now.x+dx[i]][now.y+dy[i]] != '#') {
34                     next = rot[now.x+dx[i]][now.y+dy[i]][now.dir];
35                     if(!ti[next.x][next.y][next.dir]) {
36                         ti[next.x][next.y][next.dir] = ti[now.x][now.y][now.dir] + 1;
37                         que.push(next);
38                     }
39                 }
40             }
41             if(i % 2) {
42                 next = rot[now.x][now.y][(now.dir + i) % 4];
43                 if(!ti[next.x][next.y][next.dir]) {
44                     ti[next.x][next.y][next.dir] = ti[now.x][now.y][now.dir] + 1;
45                     que.push(next);
46                 }
47             }
48         }
49     }
50     return 0;
51 }
52
53 void init() {
54     for(int i = n; i; i--)
55         for(int j = m; j; j--)
56             if(maz[i][j] != '#') {
57                 if(check(i + 1, j) && maz[i+1][j] != '#') rot[i][j][0] = rot[i+1][j][0];
58                 else rot[i][j][0].init(i, j, 0);
59                 if(check(i, j + 1) && maz[i][j+1] != '#') rot[i][j][3] = rot[i][j+1][3];
60                 else rot[i][j][3].init(i, j, 3);
61             }
62     for(int i = 1; i <= n; i++)
63         for(int j = 1; j <= m; j++)
64             if(maz[i][j] != '#') {
65                 if(check(i - 1, j) && maz[i-1][j] != '#') rot[i][j][2] = rot[i-1][j][2];
66                 else rot[i][j][2].init(i, j, 2);
67                 if(check(i, j - 1) && maz[i][j-1] != '#') rot[i][j][1] = rot[i][j-1][1];
68                 else rot[i][j][1].init(i, j, 1);
69             }
70 }
71
72 int main() {
73     while(~scanf("%d%d", &n, &m)) {
74         getchar();
75         for(int i = 1; i <= n; i++)
76             for(int j = 1; j <= m + 1; j++) {
77                 for(int k = 0; k < 4; k++) ti[i][j][k] = 0;
78                 scanf("%c", &maz[i][j]);
79                 if(maz[i][j] == '|') s.init(i, j, 0);
80             }
81         init();
82         int ans = bfs();
83         if(!ans) printf("Can not escape!\n");
84         else printf("%d\n", ans - 1);
85     }
86     return 0;
87 }

y @ The Angry Teletubbies 2011-08-15 22:37 发表评论

hdoj 3912 Turn Right - dfs

y @ The Angry Teletubbies — Mon, 15 Aug 2011 12:07:00 GMT

【题意】：一个迷宫，有一个入口和出口。一个�h想从入口�q�来�Q�然后到辑և�口，又从出口�q�来�Q�回到入口。但是他��x��走不出�q�宫�Q�于是他惛_��了一�U�走的方法：1.优先靠右边走�Q�能向右转的都向双��{ 2.不能靠右走的话就选择直走 3.双��和直走都不能走的话选择向左�?4.前面三种都不能走的话向后走。题目保证肯定存在一条从入口到出口的路，然后人必��L��照上�q�的�Ҏ��走迷宫。问最后，��否把�q�宫每个格子都走一遍？

【题解】：题目明显��是让你搜烦的，对于每个格子i,j加多一�l�记录方向就好了。由于数据最大是500*500�Q�所以用�pȝ��栈会爆掉�Q�改成非递归卛_��。如果你�׃��层理解题目的话，会发现是不需要用栈的�Q�只需要一个��@环就可以了，直接上代码了�Q�大家不懂再问吧�?br />
【代码】：

1 #include <iostream>
2 #include <cstdio>
3 using namespace std;
4 #define MAX 505
5
6 struct node {
7     int x, y, dir;
8     void init(int a, int b, int c) {
9         x = a, y = b, dir = c;
10     }
11 } s, t, goal;
12 int r, c, n, m;
13 int maz[MAX][MAX][4];
14 bool visit[MAX][MAX];
15 const int dx[] = {0, 1, 0, -1};
16 const int dy[] = {1, 0, -1, 0};
17
18 void dfs(node now, node goal) {
19     node next;
20     while (1) {
21         visit[now.x][now.y] = true;
22         if (now.x == goal.x && now.y == goal.y && now.dir == goal.dir) break;
23         for (int i = now.dir; i < 4 + now.dir; i++) {
24             int index = (now.dir - (i - now.dir) + 4) % 4;
25             if (maz[now.x][now.y][(now.dir - (i - now.dir) + 5) % 4] == 0) {
26                 next.init(now.x + dx[index], now.y + dy[index], (now.dir - (i - now.dir) + 5) % 4);
27                 now = next;
28                 break;
29             }
30         }
31     }
32 }
33
34 void init() {
35     for (int i = 1; i <= r; i++)
36         for (int j = 1; j <= c; j++) {
37             visit[i][j] = false;
38             for (int k = 0; k < 4; k++)
39                 maz[i][j][k] = 1;
40         }
41         maz[t.x][t.y][s.dir] = maz[s.x][s.y][t.dir] = 0;
42 }
43
44 int main() {
45     int T;
46     scanf("%d", &T);
47     while (T--) {
48         scanf("%d%d", &r, &c);
49         scanf("%d%d", &s.y, &t.y);
50         s.init(1, s.y + 1, 2), t.init(r, t.y + 1, 0);
51         init();
52         for (int i = 1; i < 2 * r; i++) {
53             if (i % 2 != 0) {
54                 for (int j = 1; j < c; j++) {
55                     scanf("%d", &maz[(i + 1) / 2][j][1]);
56                     maz[(i + 1) / 2][j + 1][3] = maz[(i + 1) / 2][j][1];
57                 }
58             } else {
59                 for (int j = 1; j <= c; j++) {
60                     scanf("%d", &maz[i / 2][j][2]);
61                     maz[i / 2 + 1][j][0] = maz[i / 2][j][2];
62                 }
63             }
64         }
65         goal.init(t.x + 1, t.y, s.dir);
66         dfs(s, goal);
67         goal.init(s.x - 1, s.y, t.dir);
68         dfs(t, goal);
69         bool flag = false;
70         for (int i = 1; i <= r; i++)
71             for (int j = 1; j <= c; j++)
72                 if (!visit[i][j])
73                     flag = true;
74         if (!flag) printf("YES\n");
75         else printf("NO\n");
76     }
77     return 0;
78 }

y @ The Angry Teletubbies 2011-08-15 20:07 发表评论