计算 N 次移动后骑士的所有可能访问过的单元格

给定一个骑士的当前位置为 (i, j)，找出骑士在 N 次移动后(在 10 x 10 的棋盘中)访问过的不同可能位置的数量。

例子：

Input: i = 3, j = 3, n = 1 
Output: 9 
The Knight is initially at position [3][3]. After one move it can visit 8 more cells

Input: i = 3, j = 3, n = 2 
Output: 35 

方法：思路很简单，我们从一个给定的位置开始，尝试所有可能的动作。每次移动后，递归调用 n-1 次移动。我们需要确保我们永远不会再次访问单元格。我们制作了一个访问过的布尔矩阵，它将作为一个访问过的矩阵，这样位置就不会重复。当我们访问一个位置时，在矩阵中将该位置标记为真。

脚步：-

1. 取一个布尔访问矩阵(10X10)并将所有单元格初始化为假(非访问)
2. 使用骑士的所有可能动作创建两个向量。我们发现一个骑士有 8 种可能的动作。
3. 有效位置 = 骑士位于棋盘边界内，且未访问该单元格。
4. 使用 n = n-1 调用下一个有效位置的方法。
5. 如果 n == 0，则返回。

下面是上述方法的实现：

C++14

// C++ program for the above approach
#include 
using namespace std;
 
const int N = 10;
 
// All possible moves of the knight.
 
// In X axis.
vector X = { 2, 1, -1, -2, -2, -1, 1, 2 };
 
// In Y axis.
vector Y = { 1, 2, 2, 1, -1, -2, -2, -1 };
 
void getCountRec(vector >& board,
                 int i, int j, int n)
{
    // if n=0, we have our result.
    if (n == 0)
        return;
 
    for (int k = 0; k < 8; k++) {
        int p = i + X[k];
        int q = j + Y[k];
 
        // Condition for valid cells.
        if (p >= 0 && q >= 0
            && p < 10 && q < N) {
            board[p][q] = true;
            getCountRec(board, p, q, n - 1);
        }
    }
}
 
int getCount(int i, int j, int n)
{
    vector > board(N, vector(N));
    board[i][j] = true;
 
    // Call the recursive function to mark
    // visited cells.
    getCountRec(board, i, j, n);
 
    int cnt = 0;
    for (auto row : board) {
        for (auto cell : row) {
            if (cell)
                cnt++;
        }
    }
    return cnt;
}
 
// Driver Code
int main()
{
    int i = 3, j = 3, N = 2;
    cout << getCount(i, j, N) << endl;
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
   
static int N = 10;
 
// All possible moves of the knight.
 
// In X axis.
static int[] X = { 2, 1, -1, -2, -2, -1, 1, 2 };
 
// In Y axis.
static int[] Y = { 1, 2, 2, 1, -1, -2, -2, -1 };
 
static void getCountRec(boolean[][] board,
                        int i, int j, int n)
{
     
    // If n=0, we have our result.
    if (n == 0)
        return;
 
    for(int k = 0; k < 8; k++)
    {
        int p = i + X[k];
        int q = j + Y[k];
 
        // Condition for valid cells.
        if (p >= 0 && q >= 0 &&
            p < 10 && q < N)
        {
            board[p][q] = true;
            getCountRec(board, p, q, n - 1);
        }
    }
}
 
static int getCount(int i, int j, int n)
{
    boolean[][] board = new boolean[N][N];
    board[i][j] = true;
 
    // Call the recursive function to mark
    // visited cells.
    getCountRec(board, i, j, n);
 
    int cnt = 0;
    for(boolean[] row : board)
    {
        for(boolean cell : row)
        {
            if (cell != false)
                cnt++;
        }
    }
    return cnt;
}
 
// Driver code
public static void main(String[] args)
{
    int i = 3, j = 3, N = 2;
     
    System.out.println(getCount(i, j, N));
}
}
 
// This code is contributed by sanjoy_62

输出：

35

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。