寒假培训——简单搜索

A 捉迷藏1（dfs/bfs简单搜索）

题目：

Title:
A 捉迷藏1

Time Limit: 1s

Description:
王吉吉和袁坑坑在一个n*m大小的房间里捉迷藏，王吉吉躲起来了，现在袁坑坑要去抓他，地图中‘W'代表王吉吉，‘Y’代表袁坑坑，‘.’代表空地，‘#’代表墙。求袁坑坑能不能找到王吉吉。

Input:
有多组样例，每组样例第一行有两个数字n和m，代表地图的大小n行m列。然后n行为这个地图包含'Y' 'W' '.' '#' 。
n,m<=100

Output:
对于每组测试数据，输出'YES'或者'NO'，代表袁坑坑能否找到王吉吉。

Sample Input:
5 5
....Y
#.###
.....
.##.#
.#W..

5 5
....Y
#.###
..#..
.##.#
.#W..

Sample Output:
YES
NO

题解：

数据很小深搜或者广搜随便搞下，这里代码都给了。

// A
#include <bits/stdc++.h>
#define N 1010
using namespace std;
int n,m,bx,by;
bool vis[N][N];
char g[N][N];
bool bfs(int ax,int ay)
{
    int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
    pair<int,int>now;
    queue<pair<int,int> >q;
    vis[ax][ay]=true;
    q.push(make_pair(ax,ay));//当前点加入队列
    while(!q.empty()){
        now=q.front();q.pop();
        for(int i=0;i<4;i++){
            int x=now.first+dir[i][0],y=now.second+dir[i][1];
            if(bx==x&&by==y)return true;//若找到B点，答案为真
            if(x<0||x>=n||y<0||y>=m)continue;//跳过出界的点
            //当该点尚未遍历并且不是墙时该点加入队列
            if(!vis[x][y]&&g[x][y]!='#'){
                vis[x][y]=true;
                q.push(make_pair(x,y));
            }
        }
    }
    return false;
}
bool dfs(int x,int y)//(x,y)表示当前搜索到的点
{
    int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
    for(int i=0;i<4;i++){
        //取当前点的四个方向上的点
        int xx=x+dir[i][0],yy=y+dir[i][1];
        //若找到B点，答案为真
        if(bx==xx&&by==yy)return true;
        //跳过出界的点
        if(xx<0||xx>=n||yy<0||yy>=m)continue;
        //当该点尚未遍历并且不是墙时从该点递归下去
        if(!vis[xx][yy]&&g[xx][yy]!='#'){
            vis[xx][yy]=true;
            if(dfs(xx,yy))return true;
        }
    }
    return false;
}

int main()
{
    int x,y,T;
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        memset(vis,false,sizeof(vis));
        for(int i=0;i<n;i++)
            scanf("%s",g[i]);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            {
                if(g[i][j]=='W')
                    bx=i,by=j;
                if(g[i][j]=='Y')
                    x=i,y=j;
            }
        vis[x][y]=true;
        if(dfs(x,y))printf("YES\n");//深搜写法
//        if(bfs(x,y))printf("YES\n");//广搜写法
        else printf("NO\n");
    }
    return 0;
}

数据生成：

随机乱搞的地图，看命了。

//zhaoruifeng
#include <stdio.h>
#include <stdlib.h>
int n,m;
char s[101][101];
int main()
{
    srand(123);
    int i,j,k,kk,cas,T,t,x,y,z,xx,yy;
    freopen("in.in","w",stdout);
    T=50;
    while(T--)
    {
        n=rand()%99+2;
        m=rand()%99+2;
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
                s[i][j]=rand()%5<2?'#':'.';
        }
        x=rand()%n;
        y=rand()%m;
        s[x][y]='W';
        xx=rand()%n;
        yy=rand()%m;
        while(xx==x&&yy==y)
        {
            xx=rand()%n;
            yy=rand()%m;
        }
        s[xx][yy]='Y';
        printf("%d %d\n",n,m);
        for(i=0;i<n;i++)
        {
            for(j=0;j<m;j++)
                printf("%c",s[i][j]);
            printf("\n");
        }
        printf("\n");
    }
    return 0;
}

B 捉迷藏2（dfs/bfs简单搜索）

题目：

Title:
A 捉迷藏2

Time Limit: 1s

Description:
王吉吉和袁坑坑继续在一个n*m大小的房间里捉迷藏，王吉吉躲起来了，现在袁坑坑要去抓他，但是袁坑坑老了，最多只能走a步，地图中‘W'代表王吉吉，‘Y’代表袁坑坑，‘.’代表空地，‘#’代表墙。求袁坑坑能不能找到王吉吉。

Input:
有多组样例，每组样例第一行有三个数字n和m、a，代表地图的大小n行m列，以及最多走a步。然后n行为这个地图包含'Y' 'W' '.' '#' 。
n,m<=100

Output:
对于每组测试数据，输出'YES'或者'NO'，代表袁坑坑能否找到王吉吉。

Sample Input:
5 5 10
....Y
#.###
.....
.##.#
.#W..

5 5 9
....Y
#.###
.....
.##.#
.#W..

Sample Output:
YES
NO

题解：

在上一题的基础上加上每一步的步数，可以直接在vis数组中。

// B
#include <bits/stdc++.h>
#define N 1010
using namespace std;
int n,m,bx,by,a,res;
int vis[N][N];
char g[N][N];
int bfs(int ax,int ay)
{
    int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
    pair<int,int>now;
    queue<pair<int,int> >q;
    q.push(make_pair(ax,ay));//当前点加入队列
    while(!q.empty()){
        now=q.front();q.pop();
        for(int i=0;i<4;i++){
            int x=now.first+dir[i][0],y=now.second+dir[i][1];
            if(bx==x&&by==y)return vis[now.first][now.second]+1;//若找到B点，答案为真
            if(x<0||x>=n||y<0||y>=m)continue;//跳过出界的点
            //当该点尚未遍历并且不是墙时该点加入队列
            if(vis[x][y]==-1&&g[x][y]!='#'){
                vis[x][y]=vis[now.first][now.second]+1;
                if(a<=vis[x][y])continue;///判断步数
                q.push(make_pair(x,y));
            }
        }
    }
    return -1;
}
int main()
{
    int x,y,T;
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&a);
        memset(vis,-1,sizeof(vis));
        for(int i=0;i<n;i++)
            scanf("%s",g[i]);
        for(int i=0;i<n;i++)
            for(int j=0;j<m;j++)
            {
                if(g[i][j]=='W')
                    bx=i,by=j;
                if(g[i][j]=='Y')
                    x=i,y=j;
            }
        vis[x][y]=0;
        res=-1;
        res=bfs(x,y);
        printf("%s\n",res==-1?"NO":"YES");
    }
    return 0;
}

数据生成：

基本用上一题的函数。

C 捉迷藏3（dfs/bfs简单搜索）

题目：

Title:
C 捉迷藏3

Time Limit: 1s

Description:
王吉吉和袁坑坑继续在一个有r层，每层n*m大小的楼房里捉迷藏，王吉吉躲起来了，现在袁坑坑要去抓他，地图中‘W'代表王吉吉，‘Y’代表袁坑坑，‘.’代表空地，‘#’代表墙。求袁坑坑最快几步找到王吉吉。

Input:
有多组样例，每组样例第一行有三个数字r,n和m，代表地图的大小r层n行m列。然后n行为这个地图包含'Y' 'W' '.' '#' 。
r,n,m<=30

Output:
对于每组测试数据，输出一个数代表找到王吉吉的最小步数，若找不到则为-1。

Sample Input:
3 4 5
Y....
.###.
.##..
###.#

#####
#####
##.##
##...

#####
#####
#.###
####W

1 3 3
Y##
#W#
###

Sample Output:
11
-1

题解：

// C
#include <bits/stdc++.h>
#define N 112
using namespace std;
int n,m,r,xx,yy,zz;
int flag,sum,ave,ans,res,len,ans1,ans2;
int g[N][N][N];
int dir[6][3]={1,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,-1};
char s[N];
struct node
{
    int x,y,z,step;
}tn;
int bfs(int x,int y,int z)
{
    queue<node> q;
    while(!q.empty())q.pop();
    node a,b;
    a.x=x;a.y=y;a.z=z;a.step=0;
    q.push(a);
    while(!q.empty())
    {
        a=q.front();q.pop();
        if(a.x==xx&&a.y==yy&&a.z==zz)
            return a.step;
        for(int i=0;i<6;i++)
        {
            b.x=a.x+dir[i][0];b.y=a.y+dir[i][1];b.z=a.z+dir[i][2];
            if(b.x>=n||b.x<0||b.y>=m||b.y<0||b.z>=r||b.z<0)
                continue;
            if(g[b.z][b.x][b.y])
            {
                g[b.z][b.x][b.y]=0;
                b.step=a.step+1;
                q.push(b);
            }
        }
    }
    return -1;
}
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int i,j,k,kk,t,x,y,z,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&r,&n,&m);
        memset(g,0,sizeof(g));
        for(k=0;k<r;k++)
            for(i=0;i<n;i++)
            {
                scanf("%s",s);
                int len=strlen(s);
                for(j=0;j<len;j++)
                {
                    if(s[j]=='#')
                        continue;
                    g[k][i][j]=1;
                    if(s[j]=='Y')
                        x=i,y=j,z=k;
                    if(s[j]=='W')
                        xx=i,yy=j,zz=k;
                }
            }
        printf("%d\n",bfs(x,y,z));
    }
    return 0;
}

D 烧试卷（暴力枚举BFS）

题目：

Title:
D 烧试卷

Time Limit: 1s

Description:
又一次期末结束了，吴柯大学霸感觉自己考不了满分，于是决定和队友马金昊一起去烧试卷，试卷堆在一个n*m的大房子里用‘#’表示，因为21b的看门大爷很凶残，所以他们只有一次点火的机会，烧着的试卷会在下一秒引燃旁边四个方向的试卷，求他们最快烧掉所有试卷的时间。如果无法烧掉全部试卷，输出-1。

Input:
有多组样例，每组样例第一行有两个数字n和m，代表房间的大小n行m列。然后n行为这个地图包含'.' '#' 。
n,m<=10

Output:
对于每组测试数据，输出一个数代表他们最多一人点火一次之后烧掉所有试卷所需的时间。如果无法完成输出-1。

Sample Input:
3 3
.#.
###
.#.

3 3
.#.
#.#
.#.

3 3
...
#.#
...

3 3
###
..#
#.#

Sample Output:
1
-1
0
2

题解：

所有草堆分块，超过2个块则不能烧完。暴力枚举所有的两个点的组合，bfs求出这两个点开始烧的时间，每一次都bfs依然会超时，可以提前以每一个点为起点bfs一次，确定当前起点时其他点被烧到的时间，然后枚举两点，直接得出所有其他点被烧到时间为这两点烧过去的最小值。这题要敢于暴力枚举所有的两点组合，并且扫所有点，也就是有6层循环，同注意记录。

// D
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define N 15
using namespace std;
int n,m;
int flag,sum,ave,ans,len,ans1,ans2;
int g[N][N];
int res[N][N][N][N];
int dir[4][2]={0,1,0,-1,1,0,-1,0};
bool vis[N][N];
char s[101];
struct node
{
    int x,y;
    int now;
}tn;
void bfs(int x,int y,int xx,int yy)
{
    queue<node>q;
    while(!q.empty())q.pop();
    node a,b;
    memset(vis,false,sizeof(vis));
    a.x=xx;a.y=yy;a.now=0;
    res[x][y][xx][yy]=0;
    q.push(a);
    vis[xx][yy]=true;
    while(!q.empty())
    {
        a=q.front();q.pop();
        for(int i=0;i<4;i++)
        {
            b=a;
            b.x+=dir[i][0];b.y+=dir[i][1];
            if(g[b.x][b.y]&&!vis[b.x][b.y])
            {
                vis[b.x][b.y]=true;
                b.now=a.now+1;
                res[x][y][b.x][b.y]=b.now;
                q.push(b);
            }
        }
    }
}
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int i,j,k,kk,t,x,xx,y,yy,z,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        memset(g,0,sizeof(g));
        for(i=1;i<=n;i++)
        {
            scanf("%s",s);
            for(j=1;j<=m;j++)
                if(s[j-1]=='#')
                    g[i][j]=1,ave++;
        }
        memset(res,0x3f,sizeof(res));
        for(i=1;i<=n;i++)
            for(j=1;j<=m;j++)
                if(g[i][j])
                    bfs(i,j,i,j);
        sum=INF;
        for(i=1;i<=n;i++)
            for(j=1;j<=m;j++)
                if(g[i][j])
                    for(int ii=1;ii<=n;ii++)
                        for(int jj=1;jj<=m;jj++)
                            if(g[i][j]&&g[ii][jj])
                            {
                                ans=0;
                                for(int iii=1;iii<=n;iii++)
                                    for(int jjj=1;jjj<=m;jjj++)
                                        if(g[iii][jjj])
                                            ans=max(ans,min(res[i][j][iii][jjj],res[ii][jj][iii][jjj]));
                                sum=min(sum,ans);
                            }
        if(sum==INF)
            printf("-1\n");
        else
            printf("%d\n",sum);
    }
    return 0;
}

数据生成;

同上。

E 洞洞波（暴力枚举深搜）

题目：

Title:
E 洞洞波

Time Limit: 1s

Description:
近期573的众人都学会了新的技能——洞洞波，能够打到一条线上的所有人，也就是说每个人都能打到与他站在同行同列的所有人，现在有k个人在一片梅花桩上练功，地图大小为n*n，'#'表示梅花桩,'.'表示空地。要求有多少种站法能够让所有人站在梅花桩上，并且互相不会误伤。

Input:
有多组样例，每组样例第一行有两个数字n和k，代表房间的大小n行n列，k个人练功。然后n行为这个地图包含'.' '#' 。
n,m<=8

Output:
对于每组测试数据，输出一个数代表所有的站法总数。

Sample Input:
2 1
#.
.#

4 4
...#
..#.
.#..
#...

Sample Output:
2
1

题解：

直接暴力深搜枚举所有情况即可，每一行选择一个点向下继续深搜，同时a[]储存该列是否已有棋子。

// E
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define N 15
using namespace std;
int n,m;
int flag,sum,ave,ans,res,len,ans1,ans2;
int a[N];
int g[N][N];
char s[101];
void dfs(int now,int step)
{
    if(step==m)
    {
        sum++;
        return;
    }
    if(now==n)
        return;
    for(int i=0;i<n;i++)
        if(g[now][i]&&!a[i])
        {
            a[i]=1;
            dfs(now+1,step+1);
            a[i]=0;
        }
    dfs(now+1,step);
}
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int i,j,k,kk,t,x,y,z,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        memset(g,0,sizeof(g));
        memset(a,0,sizeof(a));
        for(i=0;i<n;i++)
        {
            scanf("%s",s);
            x=strlen(s);
            for(j=0;j<x;j++)
                if(s[j]=='#')
                    g[i][j]=1;
        }
        sum=0;
        dfs(0,0);
        printf("%d\n",sum);
    }
    return 0;
}

F 小学数学（简单BFS）

题目：

Title:
F 小学数学

Time Limit: 1s

Description:
终于考完试了，但是我回到573才发现竟然只有XXX在，作为一个如此爱好数学的少年｡◕‿◕｡我当然要给他出一道数学题以示嘉奖。
题目描述如下：一个数字只能通过加一、减一或者翻番的方式变换，怎么才能最快的变成另一个数字。
我给出了一个样例：把5变成17。
XXX很快给出了一种变换：
5->10->9 ->18->17
很明显只需要4步。现在要求你变成解决这道问题，对于每一对数都给出他们变换的最小次数。

Input:
第一行有一个数字T，代表有T组样例，每组样例包含两个数字n,m。表示由n变成m。
n,m<=100000

Output:
对于每组测试数据，输出一个数代表最小的变换次数。

Sample Input:
1
5 17

Sample Output:
4

题解：

只要按+1，-1，*2三个方向扩展广搜就行了。

//F
#include <bits/stdc++.h>
#define N 212345
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
int flag,sum,ave,ans,res,len,ans1,ans2;
bool vis[N];
struct node
{
    int x,y;
}tn;
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    queue<node> q;
    node g,h;
    int i,j,k,kk,t,x,y,z,T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        while(!q.empty())q.pop();
        memset(vis,false,sizeof(vis));
        g.x=n;g.y=0;vis[n]=true;
        res=INF;
        q.push(g);
        while(res==INF&&!q.empty())
        {
            g=q.front();q.pop();
            if(g.x==m)res=g.y;
            h.x=g.x+1;h.y=g.y+1;
            if(h.x<N&&!vis[h.x])
                vis[h.x]=true,q.push(h);
            h.x=g.x-1;
            if(h.x>=0&&!vis[h.x])
                vis[h.x]=true,q.push(h);
            h.x=g.x*2;
            if(h.x<N&&!vis[h.x])
                vis[h.x]=true,q.push(h);
        }
        printf("%d\n",res);
    }
    return 0;
}

G 快跑！

题目：

Title:
G 快跑！

Time Limit: 1s

Description:
话说这一日XXX在573睡觉，也不知他梦到了什么，也不知他在梦里说了什么做了什么，突然天将神雷劈向了他，只可惜雷公这日没戴眼镜劈歪了。点燃了他旁边的一个地方，火焰每秒会向附近四个方向引燃一格，XXX每秒能往旁边四个方向跑一步。只要跑到地图外就OK了，求XXX能否逃出生天。

Input:
第一行有一个数字T，代表有T组样例，每组样例第一行有两个数字n和m，代表房间的大小n行m列。然后n行为这个地图包含'.'表示路面， '#'表示墙 ，以及'J'表示XXX的位置，'F'表示闪电劈到的位置。
n,m<=1000

Output:
对于每组测试数据，输出一个数代表他最快逃出房间的时间，如果注定命有此劫无法逃出升天请输出“exciting!”。

Sample Input:
2
4 4
####
#JF#
#..#
#..#
3 3
###
#J.
#.F

Sample Output:
3
exciting!

题解：

先BFS预处理出一个着火时间的数组，然后再BFS人跑路。

//G
#include <bits/stdc++.h>
#define N 2123
#define INF 0x3f3f3f3f
using namespace std;
int n,m;
int flag,sum,ave,ans,res,len,ans1,ans2;
int xx[N],yy[N];
int f[N][N];
int g[N][N];
int dir[4][2]={0,1,0,-1,1,0,-1,0};
bool vis[N][N];
char s[101];
struct node
{
    int x,y;
    int now;
}tn;
bool in(int x,int y)
{
    return x<=n&&x>0&&y<=m&&y>0;
}
void bfsf()
{
    queue<node>q;
    while(!q.empty())q.pop();
    node a,b;
    memset(vis,false,sizeof(vis));
    for(int i=0;i<sum;i++)
    {
        a.x=xx[i];a.y=yy[i];a.now=0;
        q.push(a);
        vis[a.x][b.y]=true;
    }
    while(!q.empty())
    {
        a=q.front();q.pop();
        for(int i=0;i<4;i++)
        {
            b=a;
            b.x=a.x+dir[i][0];b.y=a.y+dir[i][1];b.now=a.now+1;
            if(!g[b.x][b.y]&&in(b.x,b.y)&&!vis[b.x][b.y])
            {
                f[b.x][b.y]=b.now;
                vis[b.x][b.y]=true;
                q.push(b);
            }
        }
    }
}
int bfsj(int x,int y)
{
    queue<node>q;
    while(!q.empty())q.pop();
    node a,b;
    memset(vis,false,sizeof(vis));
    a.x=x;a.y=y;a.now=0;
    q.push(a);
    vis[x][y]=true;
    while(!q.empty())
    {
        a=q.front();q.pop();
        for(int i=0;i<4;i++)
        {
            b=a;
            b.x=a.x+dir[i][0];b.y=a.y+dir[i][1];b.now=a.now+1;
            if(!g[b.x][b.y]&&!vis[b.x][b.y]&&b.now<f[b.x][b.y])
            {
                if(!in(b.x,b.y))
                    return b.now;
                vis[b.x][b.y]=true;
                q.push(b);
            }
        }
    }
    return -1;
}
int main()
{
    freopen("in.in","r",stdin);
    freopen("out.out","w",stdout);
    int i,j,k,kk,t,x,y,z;
    scanf("%d",&k);
    while(k--)
    {
        scanf("%d%d",&n,&m);
        memset(g,0,sizeof(g));
        memset(f,0x3f,sizeof(f));
        sum=0;
        for(i=1;i<=n;i++)
        {
            scanf("%s",s);
            for(j=1;j<=m;j++)
            {
                if(s[j-1]=='.')
                    continue;
                g[i][j]=1;
                if(s[j-1]=='J')
                    x=i,y=j;
                if(s[j-1]=='F')
                    xx[sum]=i,yy[sum++]=j;
            }
        }
        bfsf();
        t=bfsj(x,y);
        if(t==-1)
            printf("exciting!\n");
        else
            printf("%d\n",t);
    }
    return 0;
}

H 开锁

题目：

Title:
H 开锁

Time Limit: 1s

Description:
XXX终于跑到了门口，但是你以为这样真的就安全了么。too young, too naive. 573的门锁是一个密码锁：
密码锁上有8个数字，2*4的矩阵排列，有以下三种操作：
A、其中一行的4个数字向右循环移动一格，如：1 2 3 4变成4 1 2 3。
B、上向两行互换。
C、中间4个数字顺时针旋转，如：1 2 3 4 变成 1 6 2 4
                              5 6 7 8      5 7 3 8
给出密码锁的初始状态和解锁状态，如：12345678就表示 1 2 3 4
                                                   5 6 7 8
因为ABC三种操作的耗时依次递增，所以要求求出最小字典序的一种解锁的转动方式。

Input:
第一行有一个数字T，代表有T组样例，每组样例两行代表锁的初始状态和结束状态。
n,m<=8，T<=1000000 →_→ ←_←

Output:
对于每组测试数据，输出满足题意的最小变换步骤。

Sample Input:
2
12345678
17245368
12345678
82754631

Sample Output:
C
AC

题解：

there