训练一 简搜

---

训练一 简搜

---

A-棋盘问题

题意：多组输入，输入两个整数n，k
在一个n*n的矩阵中摆放棋子。
其中’.‘为空白区域，’#'为棋子区域；q
在棋子区域摆放k个棋子，并且要求一个棋子的所在的行和列不能再摆放棋子。

思路：深搜的板子题，拜访的棋子数初始化为0；
(1)从矩阵的第一行开始,
(2)遍历每一行每一个元素寻找’#’；
(3)如果其没有被访问过，那么标记这个位置，摆放棋子数加1；
(4)然后遍历下一行,重复（2）（3)过程；
(5)如果在此过程中棋子数等于k，那么方案数加1，返回；如果遍历至最后一行也返回。

#include<stdio.h>
#include<string.h>
int visited[10];
int n,k,count;
char mark[10][10];
void dfs(int x,int y){
    int i,j;
    if(y==k){
        count++;
        return ;
    }
    if(x>=n)
        return ;
    for(j =0;j <n;j++){
        if(mark[x][j]=='#'&&!visited[j]){
            visited[j]=1;
            dfs(x+1,y+1);
            visited[j]=0;
        }
    }
    dfs(x +1, y);
}
int main(){
    int i,j;
    while(scanf("%d%d",&n,&k)!=EOF&&(n!=-1&&k!=-1)){
        count =0;
        //getchar();
        memset(visited,0,sizeof(visited));
        for(i =0;i <n;i++)
            scanf("%s",&mark[i]);
        dfs(0,0);
        printf("%d\n",count);
    }
    return 0;
}

B - Dungeon Master

题意：多组输入，当输入三个0时输入结束。
在一个3D地牢，找到从‘S’到’E’的最短路径。
其中‘.‘是路，’#'是墙，每走一步需要一分钟，如果出不去输出“Trapped!”，
如果能出去输出消耗时间，有多条路径时，输出最短路径所用的时间，输出格式为”Escaped in # minute(s).“，‘#’为所用时间。
思路： 宽搜板子题，输入时注意记录‘S’的位置，用数组表示移动，
然后开始遍历，但优先横向遍历，如果能够遍历到‘E’的位置输出时间，不能则输出“Trapped!”。

#include <iostream>
#include<string>
#include<cstring>
#include<queue>
using namespace std;

struct Node
{
    int x,y,z;
    int cont;
};
int vis[40][40][40];
char map[40][40][40];
int move[6][3]={{0,0,1},{0,0,-1},{0,1,0},{0,-1,0},{1,0,0},{-1,0,0}};
int l,r,c;
int x1,y1,z1;

void bfs(){

    queue <Node>q;
    Node t;
    t.x =x1,t.y =y1,t.z =z1,t.cont =0;
    vis[x1][y1][z1] = 1;
    q.push(t);
    while(!q.empty()){
        Node res=q.front();
        q.pop();

        int xx = res.x;
        int yy = res.y;
        int zz = res.z;
        int Cont = res.cont;

        if(map[xx][yy][zz] == 'E'){
            cout<<"Escaped in "<<Cont<<" minute(s)."<<endl;
            return ;
        }

        for(int i = 0;i < 6;i++){
            Node temp;
            int xi = temp.x =xx+ move[i][0];
            int yi = temp.y =yy+ move[i][1];
            int zi = temp.z =zz+ move[i][2];
            temp.cont =Cont +1;
            if(xi < 1||xi > l||yi < 1||yi > r||zi < 1||zi > c)    continue;
            if(map[xi][yi][zi]!='#'&&!vis[xi][yi][zi]){
                vis[xi][yi][zi]=1;
                q.push(temp);
            }
        }
    }
    cout<<"Trapped!"<<endl;
}
int main(){
    while(cin>>l>>r>>c){
        if(l == 0 && r == 0 && c == 0)  break;
        for(int i = 1;i <= l;i ++){
            for(int j = 1;j <= r;j ++){
                for(int k = 1;k <= c;k ++){
                    cin>>map[i][j][k];
                    if(map[i][j][k] == 'S')
                        x1 = i,y1 = j,z1 = k;
                }
            }
        }
        memset(vis,0,sizeof(vis));
        bfs();
    }
    return 0;
}

C - Catch That Cow

题意：假设农夫与牛在一个数轴的两个不同的位置，农夫每步可以前进或后退一格，也可以跳跃到当前坐标两倍的位置。
算出农夫要多少步才能抓住牛。
思路：已经去过的位置不能再去；
每一步选择三种方式中的一种，直到抓住牛。

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int maxn=1e6;
int n,k;
int vis[maxn+10];
struct step{
    int x,steps;
    step(int xx,int s):x(xx),steps(s){}
};
queue<step>q;
int main(){
    while(~scanf("%d%d",&n,&k)){
        memset(vis,0,sizeof(vis));
        q.push(step(n,0));
        vis[n]=1;
        while(!q.empty()){
            step s=q.front();
            if(s.x==k){
                printf("%d\n",s.steps);
                return 0;
            }
            else{
                if(s.x -1>=0&&!vis[s.x-1]){
                    q.push(step(s.x-1,s.steps+1));
                    vis[s.x-1]=1;
                }
                if(s.x +1<=maxn&&!vis[s.x+1]){
                    q.push(step(s.x+1,s.steps+1));
                    vis[s.x+1]=1;
                }
                if(s.x *2<=maxn&&!vis[s.x*2]){
                    q.push(step(s.x*2,s.steps+1));
                    vis[s.x*2]=1;
                }
                q.pop();
            }
        }
    }
    return 0;
}

E - Find The Multiple

题意：多组输入，当输入0时，输入结束。
计算输入数据的倍数（用十进制表示），但是倍数的每一位只能是0或1，
评测实施特判，即只输出一个满足条件的输入数据的倍数即可。
思路：水题，直接上代码。

#include <stdio.h>
int vis,n;
void dfs(unsigned long long x,int y);
int main(){
    while(scanf("%d",&n)!=EOF&&n){
        vis =0;
        dfs(1,0);
    }
    return 0;
}
void dfs(unsigned long long x,int y){
    if(vis)
        return ;
    if(y==19)
        return ;
    if(x%n==0){
        printf("%llu\n",x);
        vis =1;
        return ;
    }
    dfs(x*10,y+1);
    dfs(x*10+1,y+1);
}

F - Prime Path

题意：多组输入。
每次输入两个质数 ，计算将前一个质数标为后一个质数所需要的最小步数，每一步只能改变一位数字，且改变后仍然是质数。不能变为后一个质数的则输出“Impossible”。
思路：改变一次判断一次是否为质数，且每个数至多只能出现一次。

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <queue>
using namespace std;
int m,n;
int data[10000];

struct node{
    int x;
    int step;
};

int isprime(int x){
    if(x <2)    return 1;
    else
        for(int i=2;i <=sqrt(x);i++)
            if(x %i==0)
                return 1;
    return 0;
}

void bfs(){
    queue<node>Q;
    node ta;
	ta.step=0;
	ta.x=m;
	Q.push(ta);
    while(!Q.empty()){
        node df;
        df =Q.front();
        Q.pop();
        int s =df.step;
        int q =df.x;
        if(q==n){
            printf("%d\n",s);
            return ;
        }
        for(int i =1; i <=9;i +=2){ //个位
            int z = q /10 *10+i;
            if(isprime(z)==0&&data[z]==0&&z!=q){
                data[z] =1;
                node g;
				g.step=s+1;
				g.x=z;
				Q.push(g);
            }
        }
        for(int i =0;i <=9;i++){ //十位
            int z = q /100 *100+ i *10 +q %10;
            if(isprime(z)==0&&data[z]==0&&z!=q){
                data[z] =1;
                node g;
				g.step=s+1;
				g.x=z;
				Q.push(g);
            }
        }
        for(int i =0;i <=9;i++){ //百位
            int z = q /1000 *1000+ q %100 +i *100;
            if(isprime(z)==0&&data[z]==0&&z!=q){
                data[z] =1;
                node g;
				g.step=s+1;
				g.x=z;
				Q.push(g);
            }
        }
        for(int i =1;i <=9;i++){ //千位
            int z =q %1000 +i *1000;
            if(isprime(z)==0&&data[z]==0&&z!=q){
                data[z] =1;
                node g;
                g.step=s+1;
				g.x=z;
				Q.push(g);
            }
        }
    }
    printf("Impossible\n");
    return ;
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d",&m,&n);
        memset(data, 0, sizeof(data));
        data[m] =1;
        bfs();
    }
    return 0;
}

K - 迷宫问题

题意：在5*5的矩阵1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
思路：这道题评测姬的数据有缺陷，导致我侥幸AC，贴上代码。

#include<stdio.h>
int maze[5][5];
int move[4][2]={{0,1},{0,-1},{1,0},{-1,0}};
void bfs(int x,int y){
    if(x >=0&&x <5&&y >=0&&y <5&&maze[x][y]==0&&maze[4][4]==0){
        maze[x][y]=1;
        printf("(%d, %d)\n",x,y);
        for(int i =0;i <4;i++)
            bfs(x +move[i][0],y +move[i][1]);   
    }
    return ;
}
int main()
{
    for(int i=0;i <5;i++)
        for(int j=0;j <5;j++)
            scanf("%d",&maze[i][j]);
    bfs(0,0);
    return 0;
}

L - Oil Deposits

题意：多组输入，输入 0 0结束。
‘ * ’横竖斜有‘*'算一块，计算矩阵中有几块油田。
思路：与地牢类似，但有细微不同。

#include<stdio.h>
int m,n;
char map[110][110];
int move[8][2]={{0,1},{0,-1},{1,0},{-1,0},{1,1},{-1,1},{1,-1},{-1,-1}};
void dfs(int x,int y){
    if(x >=0&&x <m&&y >=0&&y <n&&map[x][y]=='@'){
        map[x][y]='*';
        for(int i =0;i <8;i++)   
            dfs(x +move[i][0],y +move[i][1]);          
    }
    return ;
}
int main()
{
    while(scanf("%d%d",&m,&n)!=EOF){
        if(m==0)
            break;
        int total =0;
        for(int i =0;i <m;i++)
            scanf("%s",&map[i]);
        for(int i =0;i <m;i++){
            for(int j =0;j <n;j++){
                if(map[i][j]=='@'){
                    total++;
                    dfs(i,j);
                }
            }
        }
        printf("%d\n",total);
    }
    return 0;
}