挑战程序系列

 1 #include <stdio.h>
 2 #include <iostream>
 3 using namespace std;
 4 char ch[102][102];
 5 int xx[4]={0,1,0,-1};
 6 int yy[4]={1,0,-1,0};
 7 int H,W,cou;
 8 void DFS(int x, int y){
 9     int a=0;
10     char b=ch[x][y];
11     ch[x][y]=‘.‘;
12     for(int i = 0; i < 4; i++)
13     {
14         int xn = x + xx[i], yn = y + yy[i];
15         if(xn >= 0 && xn < W && yn >= 0 && yn < H && ch[xn][yn] == b)
16         {
17             DFS(xn, yn);
18         }
19     }
20     return ;
21 }
22 
23 int main()
24 {
25     while(cin >> W >> H && (H && W))
26     {
27         cou = 0;
28         for(int i=0; i < W; i++)
29             for(int k=0; k < H; k++)
30             cin >> ch[i][k];
31         for(int i = 0; i < W; i++)
32                 for(int k = 0; k < H; k++)
33                     if(ch[i][k] != ‘.‘)
34                     {
35                         DFS(i, k);
36                         cou++;
37                     }
38         cout << cou << endl;
39     }
40     return 0;
41 }
42 
43 AOJ0033

 1 #include <iostream>
 2 #include <string.h>
 3 #include <algorithm>
 4 using namespace std;
 5 int dx[4]={ 0, 1, -1, 0};
 6 int dy[4]={ 1, 0, 0, -1};
 7 int map1[22][22];
 8 int xn,yn,x1,y1,H,W,y2,x2,a;
 9 void dfs(int x1, int y1, int step){
10     if(step > 10) return ;
11     for(int i = 0; i < 4; i++){//四个方向
12         int xn = x1 + dx[i], yn = y1 + dy[i];
13         if(xn == x2 && yn == y2){
14             a=min(a, step + 1);
15             continue;
16         }
17         if(map1[xn][yn] == 1)continue;
18         while(xn >= 0 && xn < W && yn >= 0 && yn < H){
19                 xn += dx[i]; yn += dy[i];//继续往下面走
20             if(xn >= 0 && xn < W && yn >= 0 && yn < H)
21             {
22                 if(map1[xn][yn] == 0) continue;//直到撞墙或终点
23                 if(xn == x2 && yn == y2){//到达终点
24                     a= min(a, step + 1);
25                     return ;
26                 }
27                 map1[xn][yn] = 0;//停下来了，继续dfs，注意dfs前后面的墙。
28                 dfs(xn - dx[i], yn - dy[i], step + 1);
29                 map1[xn][yn] = 1;
30                 break;
31             }
32         }
33     }
34 return ;
35 }
36 
37 int main()
38 {
39     while(cin >> H >> W && H != 0 && W != 0){
40      for(int i = 0; i < W; i++)
41         for(int k = 0; k < H; k++){
42             cin >> map1[i][k];
43             if(map1[i][k] == 2){
44                 x1 = i; y1 = k;
45                 map1[i][k] = 0;
46             }
47             if(map1[i][k] == 3){
48                 x2 = i;
49                 y2 = k;
50                 map1[i][k] = 1;
51             }
52         }
53         a = 99;
54         dfs(x1, y1, 0);
55         if(a == 99 || a>10) cout << "-1" << endl;
56         else cout << a <<endl;
57     }
58     return 0;
59 }

 1 #include <stdio.h>
 2 #include <queue>
 3 #include <string.h>
 4 using namespace std;
 5 int map1[305][305],step[305][305];
 6 typedef pair<int, int> P;
 7 struct stu{
 8 int x; int y; int t;
 9 };
10 struct stu ch[50002];
11 
12 int dx[5]={0, 1, 0, -1, 0};
13 int dy[5]={0, 0, 1, 0, -1};
14 
15 void zha(int M) {
16     memset(map1, -1, sizeof(map1));
17     for(int i = 0; i < M; i++)
18         for(int k = 0; k < 5; k++){//five points are burst.
19             int nx = ch[i].x + dx[k];
20             int ny = ch[i].y + dy[k];
21             if(nx >= 0 && nx < 303 && ny >= 0 && ny < 303 && (ch[i].t < map1[ny][nx] || map1[ny][nx] == -1))
22                 map1[ny][nx] = ch[i].t;//give everypoint the minimum burst time.
23         }
24 }
25 
26 int bfs() {
27 queue <P> que;
28 que.push( P (0, 0));
29 memset(step, -1, sizeof(step));
30 step[0][0]=0;
31 while(que.size()) {
32     P p= que.front();
33     que.pop();
34         if(map1[p.first][p.second] == -1){//find map1‘s -1 and print it
35             return step[p.first][p.second];
36         }
37     if(step[p.first][p.second] >= map1[p.first][p.second])continue;//the point had benn burst,so jump it
38     for(int i = 1; i < 5; i++) {//this is the point of four diretions that does not been destroy.
39         int nx = p.first + dx[i],ny = p.second + dy[i];
40         if(nx>=0 && ny >=0 &&step[nx][ny] == -1)//if it can arrive and does not exceed the map
41             {
42                  que.push(P(nx, ny));//push it to the queue and go
43                  step[nx][ny]=step[p.first][p.second]+1;//of course,step must add 1 when go.
44             }
45     }
46 }
47 return -1;
48 }
49 
50 int main()
51 {
52     int M,a;
53     while(~scanf("%d",&M))
54     {
55          for(int i=0; i<M; i++)
56             scanf("%d%d%d",&ch[i].x,&ch[i].y,&ch[i].t);
57          zha(M);
58          a=bfs();
59          printf("%d\n",a);
60     }
61     return 0;
62 }

 1 #include <iostream>
 2 #include <queue>
 3 #include <string.h>
 4 using namespace std;
 5 typedef pair<int, int> P;
 6 int sx,sy,H,W,N;
 7 char map1[1002][1002];
 8 int step[1002][1002];
 9 int dx[4] = {1,0,-1,0};
10 int dy[4] = {0,1,0,-1};
11 void find1(int g){
12 for(int i = 0; i < W; i++)
13     for(int k = 0; k < H; k++)
14         if(map1[i][k] == ‘S‘ || map1[i][k] == (g+48)){
15         if(map1[i][k] == ‘S‘) map1[i][k] =‘.‘;
16         sx = i; sy = k;
17         return ;
18     }
19 }
20 
21 int bfs(int n)
22 {
23     memset(step,-1,sizeof(step));
24     queue <P> que;
25     que.push(P (sx,sy));
26     step[sx][sy] = 0;
27     while(que.size()){
28         int x = que.front().first, y = que.front().second;
29         que.pop();
30         for(int i = 0; i < 4; i++){
31             int xn = x + dx[i], yn = y + dy[i];
32             if(xn >= 0 && xn < W && yn >= 0 && yn < H && map1[xn][yn] != ‘X‘ && step[xn][yn] == -1)
33                 {
34                     step[xn][yn] = step[x][y] + 1;
35                     if(map1[xn][yn] == (n+48))
36                         {
37                             return step[xn][yn];
38                         }
39                     que.push(P(xn, yn));
40                 }
41         }
42     }
43 return 0;
44 }
45 
46 int main()
47 {
48     cin >> W >> H >> N;
49     for(int i = 0; i < W; i++)
50         for(int k = 0; k < H; k++)
51         cin >> map1[i][k];
52     int step = 0;
53     find1(0);
54     step += bfs(1);
55     for(int i = 1; i < N; i++)
56     {
57 
58         find1(i);
59         step += bfs(i+1);
60     }
61     cout << step << endl;
62     return 0;
63 }

 1 #include <iostream>
 2 #include <queue>
 3 #include <string.h>
 4 #include <map>
 5 #include <algorithm>
 6 using namespace std;
 7 
 8 int d[4]={ 1, -1, 4, -4};
 9 map<string, int> dp;
10 
11 void bfs(){
12 queue<string> que;
13 que.push("01234567");
14 dp["01234567"] = 0;
15 while(que.size()){
16     string now =que.front();
17     que.pop();
18     int p=0;
19     for(int j = 0; j < 8; j++)
20         if(now[j] == ‘0‘){
21             p=j;
22             break;
23         }
24     for(int i = 0; i < 4; i++){
25         int pn= p + d[i];
26         if(pn >= 0 && pn < 8 && !(p == 3 && i == 0)
27          && !(p ==4 && i == 1)){
28             string next = now;
29             swap(next[p],next[pn]);
30             if(dp.find(next) == dp.end()){
31                 dp[next] = dp[now] + 1;
32                 que.push(next);
33                 }
34             }
35         }
36     }
37 return ;
38 }
39 
40 int main()
41 {
42     string line;
43     bfs();
44     while(getline(cin,line))
45     {
46      line.erase(remove(line.begin(), line.end(), ‘ ‘), line.end());
47      cout << dp[line] << endl;
48     }
49     return 0;
50 }

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <stdio.h>
 4 #include <string.h>
 5 using namespace std;
 6 int N,ch[12],sh[12],g,i,cou;
 7 bool judge[12];
 8 
 9 void solve(int a){
10     int leng=0,b=0;
11     for(int k = 0;k < i; k++)
12         if(!judge[k]){//如果没被访问过，就加入数组sh和b
13             sh[leng++] = ch[k];
14             b=b * 10 + ch[k];
15         }
16     if(sh[0] != 0 || leng == 1)
17         cou = min(cou,abs(a-b));
18     while(next_permutation(sh,sh+leng)){//（除了原数组）全排列的所有情况
19         b=0;
20         for(int k = 0; k < leng; k++)
21             b = b * 10 + sh[k];
22         if(sh[0] != 0 || leng == 1)
23             {
24                 cou = min(cou,abs(a-b));
25             }
26     }
27 return ;
28 }
29 
30 void dfs(int x, int y){
31     if(x == i/2){
32         solve(y);
33         return;
34     }
35     for(int k=0; k < i; k++){
36         if(!judge[k]){
37             if(ch[k] == 0 && x == 0 && i > 3)
38                 continue;
39             judge[k]=true;//被访问过
40             dfs(x + 1, y * 10 + ch[k]);
41             judge[k]=false;
42         }
43     }
44     return ;
45 }
46 
47 
48 int main()
49 {
50     cin >> N;
51     getchar();
52     while(N--){
53         for( i = 0;;){
54                 cin>> ch[i++];
55                 if(g=getchar() == ‘\n‘)
56                     break;
57             }
58         cou=1000000;
59         memset(judge,false,sizeof(judge));
60         dfs(0,0);
61         cout << cou <<endl;
62     }
63     return 0;
64 }

 1 #include <iostream>
 2 #include <algorithm>
 3 using namespace std;
 4 int n,sum;
 5 int tri[10][10];
 6 
 7 int main()
 8 {
 9     while(cin >> n >> sum)
10     {
11         int lie[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
12         do{
13                 for(int k = 0; k < n; k++)
14                     tri[0][k]=lie[k];//first line
15                 for(int i = 1; i < n; i++)
16                     for(int g = 0 ; g < n - i; g++)//next line
17                     tri[i][g] = tri[i-1][g] + tri[i-1][g+1];
18                 if(tri[n-1][0] == sum )
19                     break;
20         } while(next_permutation(lie, lie+n));
21 
22         for(int j = 0; j < n ; j++){
23             if(j != 0)
24                 cout << " ";
25             cout << lie[j];
26         }
27         cout << endl;
28     }
29     return 0;
30 }

 1 #include <iostream>
 2 using namespace std;
 3 int map1[5][5],cou[10000000];
 4 int a,n,h;
 5 int x1[4] = {0, 1, -1, 0};
 6 int y1[4] = {1, 0, 0, -1};
 7 
 8 void dfs(int x, int y, int c, int all){
 9 if(c == 6)
10     {
11         cou[n++] = all;
12         for(h = 0; h < n-1; h++)
13             if(all == cou[h])
14             break;
15         if(h == n-1)
16                 a++;
17         return ;
18     }
19 for(int i = 0; i < 4; i++)
20     {
21         int xn = x + x1[i], yn = y + y1[i];
22         if(xn >= 0 && xn <= 4 && yn >= 0 && yn <= 4)
23             {
24             dfs(xn, yn, c + 1, all * 10 + map1[xn][yn]);
25             }
26     }
27 return ;
28 }
29 
30 int main()
31 {
32     a = 0;
33     n = 0;
34     for(int i = 0; i < 5; i++)
35         for(int k = 0; k < 5; k++)
36         cin >> map1[i][k];
37     for(int i = 0; i < 5; i++)
38         for(int k = 0; k < 5; k++)
39         dfs(i, k, 1, map1[i][k]);
40     cout << a << endl;
41     return 0;
42 }

 1 #include <iostream>
 2 #include <bitset>
 3 using namespace std;
 4 
 5 bitset<10000> map1[10];
 6 int r,c,cou;
 7 
 8 void dfs(int all){
 9     if(all == r)
10         {
11             int num, upcou=0;
12             for(int i = 0; i < c; i++)
13                 {
14                     num=0;
15                     for(int k = 0; k < r; k++)//竖向翻转取大的
16                     if(map1[k][i])
17                     num++;
18                     upcou += max(num, r-num);
19                 }
20             cou = max(cou, upcou);
21             return;
22         }
23     dfs(all+1);//所有情况
24     map1[all].flip();
25     dfs(all+1);
26     return ;
27 }
28 int main()
29 {
30     while(cin >> r >> c)//r行c列
31     {
32         if(r == 0 && c == 0)
33             break;
34      for(int i = 0,g; i < r; i++)
35         for(int k = 0; k < c; k++)
36             {
37             cin >> g;
38             map1[i][k]=g;
39             }
40         cou = 0;
41         dfs(0);
42         cout << cou <<endl;
43     }
44     return 0;
45 }