Question

问题陈述：

约翰尼难以记住小素数。所以，他的计算机科学老师要求他经常玩下面的益智游戏。

拼图是一个3x3的棋盘，由1到9的数字组成。拼图的目的是交换拼贴，直到达到以下最终状态：

1 2 3
4 5 6
7 8 9

在每个步骤中，Johnny可以交换两个相邻的图块，如果它们的总和是素数。如果两个图块具有共同边缘，则认为它们是相邻的。

帮助Johnny找到达到目标状态所需的最短步骤数。

到目前为止我的解决方案

#include<bits/stdc++.h>

using namespace std;

bool prime[20];

int matrix[3][3];
int solved[3][3] = {
    {1,2,3},
    {4,5,6},
    {7,8,9}
};

void display()
{
    for(int row = 0; row<3;row++)
        {
            for(int col = 0;col<3;col++)
            {
                cout<<matrix[row][col]<<" ";
            }
            cout<<endl;
        }
        cout<<endl<<endl;

}

bool check(){
    for(int i=0;i<3;i++){
        for(int j=0;j<3;j++){
            if(matrix[i][j]!=solved[i][j])
                return false;
        }
    }
    return true;
}

int min(int a,int b)
{
    return (a<b)?a:b;
}

void generate(){
    memset(prime,true,sizeof(prime));
    for(int i=2;i*i<20;i++){
        if(prime[i]==true)
        {
            for(int j=2*i;j<20;j+=i)
                prime[j]=false;
        }
    }
}

int getMoves(int row, int col){
    if(row < 0 ||col< 0 || row>=3||col>=3){
        return 0;
    }
    if(check()){
        return 0;
    }

    int moves = 0;

    for(int i = row-1 ; i<= row+1 ;i++)
    {
        for(int j = col -1 ; j<=col+1;j++)
        {
            if((i!=row-1&&j!=col-1)||(i!=row+1&&j!=col+1)||(i!=row+1&&j!=col-1)||(i!=row-1&&j!=col+1)){

                if(prime[matrix[row][col]+matrix[i][j]]==true)
                {
                    moves+=getMoves(i,j);
                    int temp;
                    temp = matrix[i][j];
                    matrix[i][j] = matrix[row][col];
                    matrix[row][col] = temp;
                    display();
                }
            }   
        }
    }
    return moves;
}

int Moves(){
    int minMoves = INF;
    for(int row = 0;row<3;row++)
    {
        for(int col = 0;col<3;col++)
        {
            int moves = getMoves(row,col);
            minMoves = min(moves,minMoves);
        }
    }
    return minMoves;
}



int main(){
    generate();
    int t;
    cin>>t;
    while(t--)
    {
        for(int row = 0; row<3;row++)
        {
            for(int col = 0;col<3;col++)
            {
                cin>>matrix[row][col];
            }
        }

    }
    cout<<Moves();
}

示例测试用例

Input:
2

7 3 2 
4 1 5 
6 8 9 

9 8 5 
2 4 1 
3 7 6  

Output:
6
-1

由于内存溢出问题，程序一直在崩溃。

Answer 1

if (row < 0 || col< 0 || row >= 3 || row <= 3) {
    return 0;
}

此部分之后的代码无法访问＆＃39;因为这个条件始终为真(... row >= 3 || row <= 3)。你可能想写：(... row >= 3 || col >= 3)

Answer 2

我担心你的代码是完全错误的，我不认为它可以通过修复而不完全重写。例如，在函数getMoves()中，变量i和j可以获取值-1，因此您将面临访问冲突错误。其次，您有一个递归，但在调用递归之前不会更改数据。让我们假设你要交换7和4.在下一步（因为你没有改变输入）你可以交换4和1.但这不是一个正确的举动，因为在那个时候，4不应该在那里。第三，你的函数getMoves()可以无限循环结束。

总之，这些问题的解决方式完全不同。您可以使用backtracking algorithm，也可以使用A* algorithm。您必须评估您当前的状态。假设以下状态：

7 3 2
4 5 6
1 8 9

您可以测量该号码必须执行的移动次数才能转到正确的位置。因此，在这种情况下，1必须执行2次移动，7必须执行2次移动，2必须执行1次移动以及数字3。此状态的值为2 + 2 + 1 + 1 = 6。它被称为启发式功能。现在您可以使用此功能并将其放入A *算法中，您应该看到正确的结果。

codechef：益智游戏

2 个答案: