2664. The Knight’s Tour

Description

Given two positive integers m and n which are the height and width of a 0-indexed 2D-array board, a pair of positive integers (r, c) which is the starting position of the knight on the board.

Your task is to find an order of movements for the knight, in a manner that every cell of the board gets visited exactly once (the starting cell is considered visited and you shouldn't visit it again).

Return the array board in which the cells' values show the order of visiting the cell starting from 0 (the initial place of the knight).

Note that a knight can move from cell (r1, c1) to cell (r2, c2) if 0 <= r2 <= m - 1 and 0 <= c2 <= n - 1 and min(abs(r1 - r2), abs(c1 - c2)) = 1 and max(abs(r1 - r2), abs(c1 - c2)) = 2.

Example 1:

Input: m = 1, n = 1, r = 0, c = 0
Output: [[0]]
Explanation: There is only 1 cell and the knight is initially on it so there is only a 0 inside the 1x1 grid.


Example 2:

Input: m = 3, n = 4, r = 0, c = 0
Output: [[0,3,6,9],[11,8,1,4],[2,5,10,7]]
Explanation: By the following order of movements we can visit the entire board.
(0,0)->(1,2)->(2,0)->(0,1)->(1,3)->(2,1)->(0,2)->(2,3)->(1,1)->(0,3)->(2,2)->(1,0)

Constraints:

• 1 <= m, n <= 5
• 0 <= r <= m - 1
• 0 <= c <= n - 1
• The inputs will be generated such that there exists at least one possible order of movements with the given condition

Solutions

• class Solution {
private int[][] g;
private int m;
private int n;
private boolean ok;

public int[][] tourOfKnight(int m, int n, int r, int c) {
this.m = m;
this.n = n;
this.g = new int[m][n];
for (var row : g) {
Arrays.fill(row, -1);
}
g[r][c] = 0;
dfs(r, c);
return g;
}

private void dfs(int i, int j) {
if (g[i][j] == m * n - 1) {
ok = true;
return;
}
int[] dirs = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
for (int k = 0; k < 8; ++k) {
int x = i + dirs[k], y = j + dirs[k + 1];
if (x >= 0 && x < m && y >= 0 && y < n && g[x][y] == -1) {
g[x][y] = g[i][j] + 1;
dfs(x, y);
if (ok) {
return;
}
g[x][y] = -1;
}
}
}
}

• class Solution {
public:
vector<vector<int>> tourOfKnight(int m, int n, int r, int c) {
vector<vector<int>> g(m, vector<int>(n, -1));
g[r][c] = 0;
int dirs[9] = {-2, -1, 2, 1, -2, 1, 2, -1, -2};
bool ok = false;
function<void(int, int)> dfs = [&](int i, int j) {
if (g[i][j] == m * n - 1) {
ok = true;
return;
}
for (int k = 0; k < 8; ++k) {
int x = i + dirs[k], y = j + dirs[k + 1];
if (x >= 0 && x < m && y >= 0 && y < n && g[x][y] == -1) {
g[x][y] = g[i][j] + 1;
dfs(x, y);
if (ok) {
return;
}
g[x][y] = -1;
}
}
};
dfs(r, c);
return g;
}
};

• class Solution:
def tourOfKnight(self, m: int, n: int, r: int, c: int) -> List[List[int]]:
def dfs(i: int, j: int):
nonlocal ok
if g[i][j] == m * n - 1:
ok = True
return
for a, b in pairwise((-2, -1, 2, 1, -2, 1, 2, -1, -2)):
x, y = i + a, j + b
if 0 <= x < m and 0 <= y < n and g[x][y] == -1:
g[x][y] = g[i][j] + 1
dfs(x, y)
if ok:
return
g[x][y] = -1

g = [[-1] * n for _ in range(m)]
g[r][c] = 0
ok = False
dfs(r, c)
return g


• func tourOfKnight(m int, n int, r int, c int) [][]int {
g := make([][]int, m)
for i := range g {
g[i] = make([]int, n)
for j := range g[i] {
g[i][j] = -1
}
}
g[r][c] = 0
ok := false
var dfs func(i, j int)
dfs = func(i, j int) {
if g[i][j] == m*n-1 {
ok = true
return
}
dirs := []int{-2, -1, 2, 1, -2, 1, 2, -1, -2}
for k := 0; k < 8; k++ {
x, y := i+dirs[k], j+dirs[k+1]
if x >= 0 && x < m && y >= 0 && y < n && g[x][y] == -1 {
g[x][y] = g[i][j] + 1
dfs(x, y)
if ok {
return
}
g[x][y] = -1
}
}
}
dfs(r, c)
return g
}

• function tourOfKnight(m: number, n: number, r: number, c: number): number[][] {
const g: number[][] = Array.from({ length: m }, () => Array(n).fill(-1));
const dirs = [-2, -1, 2, 1, -2, 1, 2, -1, -2];
let ok = false;
const dfs = (i: number, j: number) => {
if (g[i][j] === m * n - 1) {
ok = true;
return;
}
for (let k = 0; k < 8; ++k) {
const [x, y] = [i + dirs[k], j + dirs[k + 1]];
if (x >= 0 && x < m && y >= 0 && y < n && g[x][y] === -1) {
g[x][y] = g[i][j] + 1;
dfs(x, y);
if (ok) {
return;
}
g[x][y] = -1;
}
}
};
g[r][c] = 0;
dfs(r, c);
return g;
}


• impl Solution {
pub fn tour_of_knight(m: i32, n: i32, r: i32, c: i32) -> Vec<Vec<i32>> {
let mut g: Vec<Vec<i32>> = vec![vec![-1; n as usize]; m as usize];
g[r as usize][c as usize] = 0;
let dirs: [i32; 9] = [-2, -1, 2, 1, -2, 1, 2, -1, -2];
let mut ok = false;

fn dfs(
i: usize,
j: usize,
g: &mut Vec<Vec<i32>>,
m: i32,
n: i32,
dirs: &[i32; 9],
ok: &mut bool
) {
if g[i][j] == m * n - 1 {
*ok = true;
return;
}
for k in 0..8 {
let x = ((i as i32) + dirs[k]) as usize;
let y = ((j as i32) + dirs[k + 1]) as usize;
if x < (m as usize) && y < (n as usize) && g[x][y] == -1 {
g[x][y] = g[i][j] + 1;
dfs(x, y, g, m, n, dirs, ok);
if *ok {
return;
}
g[x][y] = -1;
}
}
}

dfs(r as usize, c as usize, &mut g, m, n, &dirs, &mut ok);
g
}
}