给定整数i，j，k和n ，其中(i，j)是骑士在n * n棋盘上的初始位置，任务是找到骑士在精确的k次移动中可以移动到的位置数。
例子：
Input: i = 5, j = 5, k = 1, n = 10
Output: 8
Input: i = 0, j = 0, k = 2, n = 10
Output: 10
The knight can see total 10 different positions in 2nd move.
方法：使用递归方法解决问题。
首先找到骑士可以移动到的所有可能位置，如果初始位置是i，j 。单步到达所有有效位置，然后递归找到骑士可以在k – 1步之内移动到的所有可能位置。此递归的基本情况是，当k == 0 (不动)时，如果未标记棋盘的位置，则将其标记为已访问，并增加计数。最后，显示计数。
下面是上述方法的实现：
C++
// C++ implementation of above approach
#include
using namespace std;
// function that will be called recursively
int recursive_solve(int i, int j, int steps, int n,
map, int> &m)
{
// If there's no more move to make and
// this position hasn't been visited before
if (steps == 0 && m[make_pair(i, j)] == 0) {
// mark the position
m[make_pair(i, j)] = 1;
// increase the count
return 1;
}
int res = 0;
if (steps > 0) {
// valid movements for the knight
int dx[] = { -2, -1, 1, 2, -2, -1, 1, 2 };
int dy[] = { -1, -2, -2, -1, 1, 2, 2, 1 };
// find all the possible positions
// where knight can move from i, j
for (int k = 0; k < 8; k++) {
// if the positions lies within the
// chessboard
if ((dx[k] + i) >= 0
&& (dx[k] + i) <= n - 1
&& (dy[k] + j) >= 0
&& (dy[k] + j) <= n - 1) {
// call the function with k-1 moves left
res += recursive_solve(dx[k] + i, dy[k] + j,
steps - 1, n, m);
}
}
}
return res;
}
// find all the positions where the knight can
// move after k steps
int solve(int i, int j, int steps, int n)
{
map, int> m;
return recursive_solve(i, j, steps, n, m);
}
// driver code
int main()
{
int i = 0, j = 0, k = 2, n = 10;
cout << solve(i, j, k, n);
return 0;
} Java
// Java implementation of above approach
import java.util.*;
import java.awt.Point;
public class GFG
{
// function that will be called recursively
static int recursive_solve(int i, int j, int steps, int n,
HashMap m)
{
// If there's no more move to make and
// this position hasn't been visited before
if (steps == 0 && !m.containsKey(new Point(i, j)))
{
// mark the position
m.put(new Point(i, j), 1);
// increase the count
return 1;
}
int res = 0;
if (steps > 0)
{
// valid movements for the knight
int[] dx = { -2, -1, 1, 2, -2, -1, 1, 2 };
int[] dy = { -1, -2, -2, -1, 1, 2, 2, 1 };
// find all the possible positions
// where knight can move from i, j
for (int k = 0; k < 8; k++)
{
// if the positions lies within the
// chessboard
if ((dx[k] + i) >= 0
&& (dx[k] + i) <= n - 1
&& (dy[k] + j) >= 0
&& (dy[k] + j) <= n - 1)
{
// call the function with k-1 moves left
res += recursive_solve(dx[k] + i, dy[k] + j,
steps - 1, n, m);
}
}
}
return res;
}
// find all the positions where the knight can
// move after k steps
static int solve(int i, int j, int steps, int n)
{
HashMap m = new HashMap<>();
return recursive_solve(i, j, steps, n, m);
}
// Driver code
public static void main(String[] args)
{
int i = 0, j = 0, k = 2, n = 10;
System.out.print(solve(i, j, k, n));
}
}
// This code is contributed by divyeshrabadiya07. Python3
# Python3 implementation of above approach
from collections import defaultdict
# Function that will be called recursively
def recursive_solve(i, j, steps, n, m):
# If there's no more move to make and
# this position hasn't been visited before
if steps == 0 and m[(i, j)] == 0:
# mark the position
m[(i, j)] = 1
# increase the count
return 1
res = 0
if steps > 0:
# valid movements for the knight
dx = [-2, -1, 1, 2, -2, -1, 1, 2]
dy = [-1, -2, -2, -1, 1, 2, 2, 1]
# find all the possible positions
# where knight can move from i, j
for k in range(0, 8):
# If the positions lies
# within the chessboard
if (dx[k] + i >= 0 and
dx[k] + i <= n - 1 and
dy[k] + j >= 0 and
dy[k] + j <= n - 1):
# call the function with k-1 moves left
res += recursive_solve(dx[k] + i, dy[k] + j,
steps - 1, n, m)
return res
# Find all the positions where the
# knight can move after k steps
def solve(i, j, steps, n):
m = defaultdict(lambda:0)
return recursive_solve(i, j, steps, n, m)
# Driver code
if __name__ == "__main__":
i, j, k, n = 0, 0, 2, 10
print(solve(i, j, k, n))
# This code is contributed by Rituraj JainC#
// C# implementation of above approach
using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{
// function that will be called recursively
static int recursive_solve(int i, int j, int steps, int n,
Dictionary,int>m)
{
// If there's no more move to make and
// this position hasn't been visited before
if (steps == 0 && !m.ContainsKey(new Tuple(i, j))) {
// mark the position
m[new Tuple(i, j)] = 1;
// increase the count
return 1;
}
int res = 0;
if (steps > 0) {
// valid movements for the knight
int []dx = { -2, -1, 1, 2, -2, -1, 1, 2 };
int []dy = { -1, -2, -2, -1, 1, 2, 2, 1 };
// find all the possible positions
// where knight can move from i, j
for (int k = 0; k < 8; k++) {
// if the positions lies within the
// chessboard
if ((dx[k] + i) >= 0
&& (dx[k] + i) <= n - 1
&& (dy[k] + j) >= 0
&& (dy[k] + j) <= n - 1) {
// call the function with k-1 moves left
res += recursive_solve(dx[k] + i, dy[k] + j,
steps - 1, n, m);
}
}
}
return res;
}
// find all the positions where the knight can
// move after k steps
static int solve(int i, int j, int steps, int n)
{
Dictionary,int> m=new Dictionary,int>();
return recursive_solve(i, j, steps, n, m);
}
// driver code
public static void Main(params string []args)
{
int i = 0, j = 0, k = 2, n = 10;
Console.Write(solve(i, j, k, n));
}
} 输出：
10