Lianliankan Game Assistant

Informação do tópico

"Lianliankan" é um jogo de quebra-cabeça.
"Lianliankan" pode ser eliminado conectando as mesmas duas cartas com três linhas retas. As regras são simples e fáceis de usar.
Esta questão foi escrita para simular uma pessoa jogando Lianliankan, e o processo de uma pessoa simulando computador jogando Lianliankan é o seguinte:
1. Analise o jogo deste jogo e transforme o jogo em uma matriz de dois dígitos. 0 indica uma área em branco e o número indica o tipo de cartão de jogo que aparece no jogo.
2. Use o algoritmo de pesquisa de amplitude primeiro para determinar se as duas cartas de jogo podem ser eliminadas.
3. O simulador do programa clica em um par de cartas de jogo que podem ser eliminadas para eliminar.
Converta um jogo em uma matriz bidimensional da seguinte maneira:
0 0 0 0 0
0 1 2 0 0
0 0 3 4 0
0 0 0 1 0

entrar

As linhas e colunas da matriz de dois dígitos, a matriz de dois dígitos, as coordenadas do elemento inicial e as coordenadas do elemento final determinam se a carta de jogo inicial e a carta de jogo final podem ser eliminadas.

Resultado

VERDADEIRO OU FALSO

Amostra de teste

Exemplo de teste 1

4 5
0 0 0 0 0 0 1 2 0 0 0 0 3 4 0 0 0 0 1 0
1 1
3 3

TRUE

Exemplo de teste 2

5 6
0 0 0 0 0 0 0 1 2 3 0 0 3 0 0 0 0 3 0 2 3 4 0 2 0 0 0 2 1 4
1 1
4 4

TRUE

Exemplo de teste 3

5 6
0 0 0 0 0 0 0 1 2 3 0 0 3 0 0 0 0 3 0 2 3 4 0 2 0 0 0 2 1 4
3 3
4 5

FALSE

responda

#include<iostream>
#include<queue>

using namespace std;

int Map[1000][1000] = {
    
    0};
int vir[1000][1000] = {
    
    0};
int m, n, StartX, StartY, EndX, EndY;
int trend[4][2] = {
    
    {
    
    0,  1},
                   {
    
    0,  -1},
                   {
    
    1,  0},
                   {
    
    -1, 0}};//0-下，1-上，2-右，3-左
struct Node
{
    
    
    int x, y;//坐标
    int dir; //方向
    int turn;//转弯次数
};

void BFS()
{
    
    
    queue<Node> q;
    Node k0, k1, t0;
    bool flag = false;
    for (int i = 0; i < 4; i++)
    {
    
    //初始化四个方向的点
        t0.x = StartX + trend[i][0];
        t0.y = StartY + trend[i][1];
        t0.dir = i;
        t0.turn = 1;
        vir[t0.x][t0.y] = t0.turn;
        q.push(t0);
    }
    while (!q.empty())
    {
    
    //在队列中开始广度优先搜索
        k0 = q.front();
        q.pop();
        if (k0.x == EndX && k0.y == EndY)
        {
    
    //找到了终点
            flag = true;
            cout << "TRUE" << endl;
            break;
        }
        for (int i = 0; i < 4; i++)
        {
    
    //对当前点遍历四个方向
            k1.x = k0.x + trend[i][0];
            k1.y = k0.y + trend[i][1];
            k1.dir = i;
            if (k1.dir != k0.dir)
            {
    
    //方向发生改变则相当于转弯了
                k1.turn = k0.turn + 1;
            }
            else
            {
    
    
                k1.turn = k0.turn;
            }

            if (k1.turn > 3 || k1.x < 0 || k1.y < 0 || k1.x > m - 1 || k1.y > n - 1)
            {
    
    //如果边树大于三条边了或者是超出地图范围了就不考虑了直接下一个
                continue;
            }
            if (Map[k1.x][k1.y] != 0 && Map[k1.x][k1.y] != Map[EndX][EndY])
            {
    
    //如果在地图上这个点不是0且不是终点，相当于走不通，也不考虑了直接下一个
                continue;
            }
            if (vir[k1.x][k1.y] == 0 || vir[k1.x][k1.y] >= k1.turn)
            {
    
    //如果是个未访问对点，或者是转向角度低于图中的点。
                //因为图中转向角度大的点相当于已经访问过了，甚至是已经到3不符合要求的点
                vir[k1.x][k1.y] = k1.turn;//更新我们刚算的转向值
                q.push(k1);//并压入队列等待下一轮判定
            }
        }
    }
    if (!flag)
    {
    
    
        cout << "FALSE" << endl;
    }
}

int main()
{
    
    
    //freopen("/Users/zhj/Downloads/test.txt", "r", stdin);
    cin >> m >> n;
    for (int i = 0; i < m; i++)
    {
    
    
        for (int j = 0; j < n; j++)
        {
    
    
            cin >> Map[i][j];
        }
    }
    cin >> StartX >> StartY >> EndX >> EndY;
    BFS();
    return 0;
}