Codeforces 586D Phillip and Trains【思维+Bfs】好题~！

最新推荐文章于 2019-07-31 09:15:36 发布

原创最新推荐文章于 2019-07-31 09:15:36 发布 · 683 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Codeforces 586D

思维同时被 2 个专栏收录

692 篇文章

订阅专栏

搜索

224 篇文章

订阅专栏

本文介绍了一款名为“Subway Roller”的游戏，玩家需操控角色Philip穿越布满移动列车的隧道到达另一端。文章详细解析了游戏规则，并提供了一种利用广度优先搜索(BFS)算法来解决游戏策略的方法。

The mobile application store has a new game called "Subway Roller".

The protagonist of the game Philip is located in one end of the tunnel and wants to get out of the other one. The tunnel is a rectangular field consisting of three rows and n columns. At the beginning of the game the hero is in some cell of the leftmost column. Some number of trains rides towards the hero. Each train consists of two or more neighbouring cells in some row of the field.

All trains are moving from right to left at a speed of two cells per second, and the hero runs from left to right at the speed of one cell per second. For simplicity, the game is implemented so that the hero and the trains move in turns. First, the hero moves one cell to the right, then one square up or down, or stays idle. Then all the trains move twice simultaneously one cell to the left. Thus, in one move, Philip definitely makes a move to the right and can move up or down. If at any point, Philip is in the same cell with a train, he loses. If the train reaches the left column, it continues to move as before, leaving the tunnel.

Your task is to answer the question whether there is a sequence of movements of Philip, such that he would be able to get to the rightmost column.

$\text{[math]}$

Input

Each test contains from one to ten sets of the input data. The first line of the test contains a single integer t (1 ≤ t ≤ 10 for pretests and tests or t = 1 for hacks; see the Notes section for details) — the number of sets.

Then follows the description of t sets of the input data.

The first line of the description of each set contains two integers n, k (2 ≤ n ≤ 100, 1 ≤ k ≤ 26) — the number of columns on the field and the number of trains. Each of the following three lines contains the sequence of n character, representing the row of the field where the game is on. Philip's initial position is marked as 's', he is in the leftmost column. Each of the k trains is marked by some sequence of identical uppercase letters of the English alphabet, located in one line. Distinct trains are represented by distinct letters. Character '.' represents an empty cell, that is, the cell that doesn't contain either Philip or the trains.

Output

For each set of the input data print on a single line word YES, if it is possible to win the game and word NO otherwise.

Examples

Input

2
16 4
...AAAAA........
s.BBB......CCCCC
........DDDDD...
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....

Output

YES
NO

Input

2
10 4
s.ZZ......
.....AAABB
.YYYYYY...
10 4
s.ZZ......
....AAAABB
.YYYYYY...

Output

YES
NO

Note

In the first set of the input of the first sample Philip must first go forward and go down to the third row of the field, then go only forward, then go forward and climb to the second row, go forward again and go up to the first row. After that way no train blocks Philip's path, so he can go straight to the end of the tunnel.

Note that in this problem the challenges are restricted to tests that contain only one testset.

题目大意：

一开始人在s处，'.'表示空地，字母表示火车的一部分。

游戏规则：

①人物走到最右侧就算胜利。

②每一回合人先向右走一步，然后可以再向上走一步，或者向下走一步或者不动。然后所有的火车都向左移动两个格子。

③火车从左边穿过的时候会再从右边穿出来。

思路：

1、我们考虑物体的相对静止理论，如果我们每个回合人走完之后火车再向左走两步，其实就相当于每个回合人走完之后，再强制向右走两步。那么这个图是不变的。

火车相对静止，所以我们Bfs处理即可。

2、每次人必须向右走一步，然后判断我们可以有三种走法：上，不动，下。

按照这种方式走完之后，必须强制再向右走两步。

一直Bfs下去，如果走到了最右侧，那么就是胜利，否则就是失败。

3、因为再强制向右走两步有可能会走出去这个图，所以初始化的时候，要在最后再多加上几个‘.’空地。

注意，memset不可取。

因为输入的时候自动会在a【i】【n】处有一个'\0'，而并非是一个‘.’了。

（因为这个东西我Wa了一个小时，查错查到我觉得我买了一个假脑子。）

Ac代码：

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
struct node
{
    int x,y;
} now,nex;
char a[5][1060];
int vis[5][1060];
int fx[3]= {-1,0,1};
int n,k;
int Bfs(int sx,int sy)
{
    memset(vis,0,sizeof(vis));
    now.x=sx;
    now.y=sy;
    vis[sx][sy]=1;
    queue<node >s;
    s.push(now);
    while(!s.empty())
    {
        now=s.front();
        //printf("%d %d\n",now.x,now.y);
        s.pop();
        if(now.y>=n-1)
        {
            return 1;
        }
        now.y+=1;
        if(a[now.x][now.y]=='.')
        {
            for(int i=0; i<3; i++)
            {
                nex.x=now.x+fx[i];
                nex.y=now.y;
                if(nex.x>=0&&nex.x<3)
                {
                    if(a[nex.x][nex.y]=='.'&&a[nex.x][nex.y+1]=='.'&&a[nex.x][nex.y+2]=='.')
                    {
                        if(vis[nex.x][nex.y+2]==0)
                        {
                            vis[nex.x][nex.y+2]=1;
                            nex.y+=2;
                            s.push(nex);
                        }
                    }
                }
            }
        }
    }
    return 0;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {

        int sx,sy;
        scanf("%d%d",&n,&k);
        memset(a,'.',sizeof(a));
        for(int i=0; i<3; i++)
        {
            scanf("%s",a[i]);
            for(int j=0; j<n; j++)
            {
                if(a[i][j]=='s')
                {
                    sx=i;
                    sy=j;
                }
            }
            for(int j=n;j<n*2;j++)a[i][j]='.';
        }
        int ans=Bfs(sx,sy);
        if(ans==1)printf("YES\n");
        else printf("NO\n");
    }
}