📌  相关文章
📜  骑士可以精确移动k次棋盘中棋子的数量

📅  最后修改于: 2021-06-25 23:23:32             🧑  作者: Mango

给定整数i,j,k和n ,其中(i,j)是骑士在n * n棋盘上的初始位置,任务是找到骑士在精确的k次移动中可以移动到的位置数。
例子:

方法:使用递归方法解决问题。
首先找到骑士可以移动到的所有可能位置,如果初始位置是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 Jain


C#
// 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

如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。