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 <= 50 <= r <= m - 10 <= c <= n - 1- The inputs will be generated such that there exists at least one possible order of movements with the given condition
Solutions
Solution 1: Backtracking
We create a two-dimensional array g, used to record the knight's movement order, initially g[r][c] = -1, and all other positions are set to -1 as well. Additionally, we need a variable ok to record whether a solution has been found.
Next, we start depth-first search from (r, c). Each time we search position (i, j), we first check if g[i][j] equals m × n - 1. If so, it means we have found a solution, then we set ok to true and return. Otherwise, we enumerate the knight's eight possible movement directions to position (x, y). If 0 ≤ x < m, 0 ≤ y < n, and g[x][y]=-1, then we update g[x][y] to g[i][j]+1, and recursively search position (x, y). If after the search, the variable ok is true, we return directly. Otherwise, we reset g[x][y] to -1 and continue searching in other directions.
Finally, return the two-dimensional array g.
The time complexity is O(8m × n), and the space complexity is O(m × n). Here, m and n are the integers given in the problem.
PythonJavaC++GoTypeScriptRust
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(code-box)
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;
}
}
}
}(code-box)
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;
}
};(code-box)
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
}(code-box)
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;
}(code-box)
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
}
}(code-box)
