Assistant de jeu Lianliankan

Informations sur le sujet

"Lianliankan" est un jeu de puzzle.
"Lianliankan" peut être éliminé en connectant les deux mêmes cartes avec trois lignes droites. Les règles sont simples et faciles à utiliser.
Cette question est écrite pour simuler une personne jouant au jeu de Lianliankan, et le processus d'une personne simulant par ordinateur jouant à Lianliankan est le suivant:
1. Analysez le jeu de ce jeu et transformez le jeu en un tableau à deux chiffres. 0 indique une zone vide et le nombre indique le type de carte de jeu qui apparaît dans le jeu.
2. Utilisez le premier algorithme de recherche en largeur pour déterminer si les deux cartes de jeu peuvent être éliminées.
3. Le simulateur de programme clique sur une paire de cartes de jeu qui peuvent être éliminées pour être éliminées.
Convertissez un jeu en un tableau à deux dimensions comme suit:
0 0 0 0 0
0 1 2 0 0
0 0 3 4 0
0 0 0 1 0

entrer

Les lignes et les colonnes du tableau à deux chiffres, le tableau à deux chiffres, les coordonnées de l'élément de départ et les coordonnées de l'élément de fin déterminent si la carte de jeu de départ et la carte de jeu de fin peuvent être éliminées.

Production

VRAI OU FAUX

Échantillon de test

Exemple de test 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

Exemple de test 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

Exemple de test 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

réponse

#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;
}