--- comments: true --- # 13.4 n 皇后問題 !!! question 根據國際象棋的規則，皇后可以攻擊與同處一行、一列或一條斜線上的棋子。給定 $n$ 個皇后和一個 $n \times n$ 大小的棋盤，尋找使得所有皇后之間無法相互攻擊的擺放方案。如圖 13-15 所示，當 $n = 4$ 時，共可以找到兩個解。從回溯演算法的角度看，$n \times n$ 大小的棋盤共有 $n^2$ 個格子，給出了所有的選擇 `choices` 。在逐個放置皇后的過程中，棋盤狀態在不斷地變化，每個時刻的棋盤就是狀態 `state` 。 ![4 皇后問題的解](n_queens_problem.assets/solution_4_queens.png){ class="animation-figure" }

圖 13-15 4 皇后問題的解

圖 13-16 展示了本題的三個約束條件：**多個皇后不能在同一行、同一列、同一條對角線上**。值得注意的是，對角線分為主對角線 `\` 和次對角線 `/` 兩種。 ![n 皇后問題的約束條件](n_queens_problem.assets/n_queens_constraints.png){ class="animation-figure" }

圖 13-16 n 皇后問題的約束條件

### 1. 逐行放置策略皇后的數量和棋盤的行數都為 $n$ ，因此我們容易得到一個推論：**棋盤每行都允許且只允許放置一個皇后**。也就是說，我們可以採取逐行放置策略：從第一行開始，在每行放置一個皇后，直至最後一行結束。圖 13-17 所示為 4 皇后問題的逐行放置過程。受畫幅限制，圖 13-17 僅展開了第一行的其中一個搜尋分支，並且將不滿足列約束和對角線約束的方案都進行了剪枝。 ![逐行放置策略](n_queens_problem.assets/n_queens_placing.png){ class="animation-figure" }

圖 13-17 逐行放置策略

從本質上看，**逐行放置策略起到了剪枝的作用**，它避免了同一行出現多個皇后的所有搜尋分支。 ### 2. 列與對角線剪枝為了滿足列約束，我們可以利用一個長度為 $n$ 的布林型陣列 `cols` 記錄每一列是否有皇后。在每次決定放置前，我們透過 `cols` 將已有皇后的列進行剪枝，並在回溯中動態更新 `cols` 的狀態。 !!! tip 請注意，矩陣的起點位於左上角，其中行索引從上到下增加，列索引從左到右增加。那麼，如何處理對角線約束呢？設棋盤中某個格子的行列索引為 $(row, col)$ ，選定矩陣中的某條主對角線，我們發現該對角線上所有格子的行索引減列索引都相等，**即主對角線上所有格子的 $row - col$ 為恆定值**。也就是說，如果兩個格子滿足 $row_1 - col_1 = row_2 - col_2$ ，則它們一定處在同一條主對角線上。利用該規律，我們可以藉助圖 13-18 所示的陣列 `diags1` 記錄每條主對角線上是否有皇后。同理，**次對角線上的所有格子的 $row + col$ 是恆定值**。我們同樣也可以藉助陣列 `diags2` 來處理次對角線約束。 ![處理列約束和對角線約束](n_queens_problem.assets/n_queens_cols_diagonals.png){ class="animation-figure" }

圖 13-18 處理列約束和對角線約束

### 3. 程式碼實現請注意，$n$ 維方陣中 $row - col$ 的範圍是 $[-n + 1, n - 1]$ ，$row + col$ 的範圍是 $[0, 2n - 2]$ ，所以主對角線和次對角線的數量都為 $2n - 1$ ，即陣列 `diags1` 和 `diags2` 的長度都為 $2n - 1$ 。 === "Python" ```python title="n_queens.py" def backtrack( row: int, n: int, state: list[list[str]], res: list[list[list[str]]], cols: list[bool], diags1: list[bool], diags2: list[bool], ): """回溯演算法：n 皇后""" # 當放置完所有行時，記錄解 if row == n: res.append([list(row) for row in state]) return # 走訪所有列 for col in range(n): # 計算該格子對應的主對角線和次對角線 diag1 = row - col + n - 1 diag2 = row + col # 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if not cols[col] and not diags1[diag1] and not diags2[diag2]: # 嘗試：將皇后放置在該格子 state[row][col] = "Q" cols[col] = diags1[diag1] = diags2[diag2] = True # 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2) # 回退：將該格子恢復為空位 state[row][col] = "#" cols[col] = diags1[diag1] = diags2[diag2] = False def n_queens(n: int) -> list[list[list[str]]]: """求解 n 皇后""" # 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 state = [["#" for _ in range(n)] for _ in range(n)] cols = [False] * n # 記錄列是否有皇后 diags1 = [False] * (2 * n - 1) # 記錄主對角線上是否有皇后 diags2 = [False] * (2 * n - 1) # 記錄次對角線上是否有皇后 res = [] backtrack(0, n, state, res, cols, diags1, diags2) return res ``` === "C++" ```cpp title="n_queens.cpp" /* 回溯演算法：n 皇后 */ void backtrack(int row, int n, vector> &state, vector>> &res, vector &cols, vector &diags1, vector &diags2) { // 當放置完所有行時，記錄解 if (row == n) { res.push_back(state); return; } // 走訪所有列 for (int col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 int diag1 = row - col + n - 1; int diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state[row][col] = "Q"; cols[col] = diags1[diag1] = diags2[diag2] = true; // 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = "#"; cols[col] = diags1[diag1] = diags2[diag2] = false; } } } /* 求解 n 皇后 */ vector>> nQueens(int n) { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 vector> state(n, vector(n, "#")); vector cols(n, false); // 記錄列是否有皇后 vector diags1(2 * n - 1, false); // 記錄主對角線上是否有皇后 vector diags2(2 * n - 1, false); // 記錄次對角線上是否有皇后 vector>> res; backtrack(0, n, state, res, cols, diags1, diags2); return res; } ``` === "Java" ```java title="n_queens.java" /* 回溯演算法：n 皇后 */ void backtrack(int row, int n, List> state, List>> res, boolean[] cols, boolean[] diags1, boolean[] diags2) { // 當放置完所有行時，記錄解 if (row == n) { List> copyState = new ArrayList<>(); for (List sRow : state) { copyState.add(new ArrayList<>(sRow)); } res.add(copyState); return; } // 走訪所有列 for (int col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 int diag1 = row - col + n - 1; int diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state.get(row).set(col, "Q"); cols[col] = diags1[diag1] = diags2[diag2] = true; // 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state.get(row).set(col, "#"); cols[col] = diags1[diag1] = diags2[diag2] = false; } } } /* 求解 n 皇后 */ List>> nQueens(int n) { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 List> state = new ArrayList<>(); for (int i = 0; i < n; i++) { List row = new ArrayList<>(); for (int j = 0; j < n; j++) { row.add("#"); } state.add(row); } boolean[] cols = new boolean[n]; // 記錄列是否有皇后 boolean[] diags1 = new boolean[2 * n - 1]; // 記錄主對角線上是否有皇后 boolean[] diags2 = new boolean[2 * n - 1]; // 記錄次對角線上是否有皇后 List>> res = new ArrayList<>(); backtrack(0, n, state, res, cols, diags1, diags2); return res; } ``` === "C#" ```csharp title="n_queens.cs" /* 回溯演算法：n 皇后 */ void Backtrack(int row, int n, List> state, List>> res, bool[] cols, bool[] diags1, bool[] diags2) { // 當放置完所有行時，記錄解 if (row == n) { List> copyState = []; foreach (List sRow in state) { copyState.Add(new List(sRow)); } res.Add(copyState); return; } // 走訪所有列 for (int col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 int diag1 = row - col + n - 1; int diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state[row][col] = "Q"; cols[col] = diags1[diag1] = diags2[diag2] = true; // 放置下一行 Backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = "#"; cols[col] = diags1[diag1] = diags2[diag2] = false; } } } /* 求解 n 皇后 */ List>> NQueens(int n) { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 List> state = []; for (int i = 0; i < n; i++) { List row = []; for (int j = 0; j < n; j++) { row.Add("#"); } state.Add(row); } bool[] cols = new bool[n]; // 記錄列是否有皇后 bool[] diags1 = new bool[2 * n - 1]; // 記錄主對角線上是否有皇后 bool[] diags2 = new bool[2 * n - 1]; // 記錄次對角線上是否有皇后 List>> res = []; Backtrack(0, n, state, res, cols, diags1, diags2); return res; } ``` === "Go" ```go title="n_queens.go" /* 回溯演算法：n 皇后 */ func backtrack(row, n int, state *[][]string, res *[][][]string, cols, diags1, diags2 *[]bool) { // 當放置完所有行時，記錄解 if row == n { newState := make([][]string, len(*state)) for i, _ := range newState { newState[i] = make([]string, len((*state)[0])) copy(newState[i], (*state)[i]) } *res = append(*res, newState) return } // 走訪所有列 for col := 0; col < n; col++ { // 計算該格子對應的主對角線和次對角線 diag1 := row - col + n - 1 diag2 := row + col // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if !(*cols)[col] && !(*diags1)[diag1] && !(*diags2)[diag2] { // 嘗試：將皇后放置在該格子 (*state)[row][col] = "Q" (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = true, true, true // 放置下一行 backtrack(row+1, n, state, res, cols, diags1, diags2) // 回退：將該格子恢復為空位 (*state)[row][col] = "#" (*cols)[col], (*diags1)[diag1], (*diags2)[diag2] = false, false, false } } } /* 求解 n 皇后 */ func nQueens(n int) [][][]string { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 state := make([][]string, n) for i := 0; i < n; i++ { row := make([]string, n) for i := 0; i < n; i++ { row[i] = "#" } state[i] = row } // 記錄列是否有皇后 cols := make([]bool, n) diags1 := make([]bool, 2*n-1) diags2 := make([]bool, 2*n-1) res := make([][][]string, 0) backtrack(0, n, &state, &res, &cols, &diags1, &diags2) return res } ``` === "Swift" ```swift title="n_queens.swift" /* 回溯演算法：n 皇后 */ func backtrack(row: Int, n: Int, state: inout [[String]], res: inout [[[String]]], cols: inout [Bool], diags1: inout [Bool], diags2: inout [Bool]) { // 當放置完所有行時，記錄解 if row == n { res.append(state) return } // 走訪所有列 for col in 0 ..< n { // 計算該格子對應的主對角線和次對角線 let diag1 = row - col + n - 1 let diag2 = row + col // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if !cols[col] && !diags1[diag1] && !diags2[diag2] { // 嘗試：將皇后放置在該格子 state[row][col] = "Q" cols[col] = true diags1[diag1] = true diags2[diag2] = true // 放置下一行 backtrack(row: row + 1, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2) // 回退：將該格子恢復為空位 state[row][col] = "#" cols[col] = false diags1[diag1] = false diags2[diag2] = false } } } /* 求解 n 皇后 */ func nQueens(n: Int) -> [[[String]]] { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 var state = Array(repeating: Array(repeating: "#", count: n), count: n) var cols = Array(repeating: false, count: n) // 記錄列是否有皇后 var diags1 = Array(repeating: false, count: 2 * n - 1) // 記錄主對角線上是否有皇后 var diags2 = Array(repeating: false, count: 2 * n - 1) // 記錄次對角線上是否有皇后 var res: [[[String]]] = [] backtrack(row: 0, n: n, state: &state, res: &res, cols: &cols, diags1: &diags1, diags2: &diags2) return res } ``` === "JS" ```javascript title="n_queens.js" /* 回溯演算法：n 皇后 */ function backtrack(row, n, state, res, cols, diags1, diags2) { // 當放置完所有行時，記錄解 if (row === n) { res.push(state.map((row) => row.slice())); return; } // 走訪所有列 for (let col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 const diag1 = row - col + n - 1; const diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state[row][col] = 'Q'; cols[col] = diags1[diag1] = diags2[diag2] = true; // 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = '#'; cols[col] = diags1[diag1] = diags2[diag2] = false; } } } /* 求解 n 皇后 */ function nQueens(n) { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 const state = Array.from({ length: n }, () => Array(n).fill('#')); const cols = Array(n).fill(false); // 記錄列是否有皇后 const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后 const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后 const res = []; backtrack(0, n, state, res, cols, diags1, diags2); return res; } ``` === "TS" ```typescript title="n_queens.ts" /* 回溯演算法：n 皇后 */ function backtrack( row: number, n: number, state: string[][], res: string[][][], cols: boolean[], diags1: boolean[], diags2: boolean[] ): void { // 當放置完所有行時，記錄解 if (row === n) { res.push(state.map((row) => row.slice())); return; } // 走訪所有列 for (let col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 const diag1 = row - col + n - 1; const diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state[row][col] = 'Q'; cols[col] = diags1[diag1] = diags2[diag2] = true; // 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = '#'; cols[col] = diags1[diag1] = diags2[diag2] = false; } } } /* 求解 n 皇后 */ function nQueens(n: number): string[][][] { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 const state = Array.from({ length: n }, () => Array(n).fill('#')); const cols = Array(n).fill(false); // 記錄列是否有皇后 const diags1 = Array(2 * n - 1).fill(false); // 記錄主對角線上是否有皇后 const diags2 = Array(2 * n - 1).fill(false); // 記錄次對角線上是否有皇后 const res: string[][][] = []; backtrack(0, n, state, res, cols, diags1, diags2); return res; } ``` === "Dart" ```dart title="n_queens.dart" /* 回溯演算法：n 皇后 */ void backtrack( int row, int n, List> state, List>> res, List cols, List diags1, List diags2, ) { // 當放置完所有行時，記錄解 if (row == n) { List> copyState = []; for (List sRow in state) { copyState.add(List.from(sRow)); } res.add(copyState); return; } // 走訪所有列 for (int col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 int diag1 = row - col + n - 1; int diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state[row][col] = "Q"; cols[col] = true; diags1[diag1] = true; diags2[diag2] = true; // 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = "#"; cols[col] = false; diags1[diag1] = false; diags2[diag2] = false; } } } /* 求解 n 皇后 */ List>> nQueens(int n) { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 List> state = List.generate(n, (index) => List.filled(n, "#")); List cols = List.filled(n, false); // 記錄列是否有皇后 List diags1 = List.filled(2 * n - 1, false); // 記錄主對角線上是否有皇后 List diags2 = List.filled(2 * n - 1, false); // 記錄次對角線上是否有皇后 List>> res = []; backtrack(0, n, state, res, cols, diags1, diags2); return res; } ``` === "Rust" ```rust title="n_queens.rs" /* 回溯演算法：n 皇后 */ fn backtrack( row: usize, n: usize, state: &mut Vec>, res: &mut Vec>>, cols: &mut [bool], diags1: &mut [bool], diags2: &mut [bool], ) { // 當放置完所有行時，記錄解 if row == n { res.push(state.clone()); return; } // 走訪所有列 for col in 0..n { // 計算該格子對應的主對角線和次對角線 let diag1 = row + n - 1 - col; let diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if !cols[col] && !diags1[diag1] && !diags2[diag2] { // 嘗試：將皇后放置在該格子 state[row][col] = "Q".into(); (cols[col], diags1[diag1], diags2[diag2]) = (true, true, true); // 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = "#".into(); (cols[col], diags1[diag1], diags2[diag2]) = (false, false, false); } } } /* 求解 n 皇后 */ fn n_queens(n: usize) -> Vec>> { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 let mut state: Vec> = vec![vec!["#".to_string(); n]; n]; let mut cols = vec![false; n]; // 記錄列是否有皇后 let mut diags1 = vec![false; 2 * n - 1]; // 記錄主對角線上是否有皇后 let mut diags2 = vec![false; 2 * n - 1]; // 記錄次對角線上是否有皇后 let mut res: Vec>> = Vec::new(); backtrack( 0, n, &mut state, &mut res, &mut cols, &mut diags1, &mut diags2, ); res } ``` === "C" ```c title="n_queens.c" /* 回溯演算法：n 皇后 */ void backtrack(int row, int n, char state[MAX_SIZE][MAX_SIZE], char ***res, int *resSize, bool cols[MAX_SIZE], bool diags1[2 * MAX_SIZE - 1], bool diags2[2 * MAX_SIZE - 1]) { // 當放置完所有行時，記錄解 if (row == n) { res[*resSize] = (char **)malloc(sizeof(char *) * n); for (int i = 0; i < n; ++i) { res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1)); strcpy(res[*resSize][i], state[i]); } (*resSize)++; return; } // 走訪所有列 for (int col = 0; col < n; col++) { // 計算該格子對應的主對角線和次對角線 int diag1 = row - col + n - 1; int diag2 = row + col; // 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if (!cols[col] && !diags1[diag1] && !diags2[diag2]) { // 嘗試：將皇后放置在該格子 state[row][col] = 'Q'; cols[col] = diags1[diag1] = diags2[diag2] = true; // 放置下一行 backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2); // 回退：將該格子恢復為空位 state[row][col] = '#'; cols[col] = diags1[diag1] = diags2[diag2] = false; } } } /* 求解 n 皇后 */ char ***nQueens(int n, int *returnSize) { char state[MAX_SIZE][MAX_SIZE]; // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 for (int i = 0; i < n; ++i) { for (int j = 0; j < n; ++j) { state[i][j] = '#'; } state[i][n] = '\0'; } bool cols[MAX_SIZE] = {false}; // 記錄列是否有皇后 bool diags1[2 * MAX_SIZE - 1] = {false}; // 記錄主對角線上是否有皇后 bool diags2[2 * MAX_SIZE - 1] = {false}; // 記錄次對角線上是否有皇后 char ***res = (char ***)malloc(sizeof(char **) * MAX_SIZE); *returnSize = 0; backtrack(0, n, state, res, returnSize, cols, diags1, diags2); return res; } ``` === "Kotlin" ```kotlin title="n_queens.kt" /* 回溯演算法：n 皇后 */ fun backtrack( row: Int, n: Int, state: MutableList>, res: MutableList>?>, cols: BooleanArray, diags1: BooleanArray, diags2: BooleanArray ) { // 當放置完所有行時，記錄解 if (row == n) { val copyState = mutableListOf>() for (sRow in state) { copyState.add(sRow.toMutableList()) } res.add(copyState) return } // 走訪所有列 for (col in 0..>?> { // 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 val state = mutableListOf>() for (i in 0..() for (j in 0..>?>() backtrack(0, n, state, res, cols, diags1, diags2) return res } ``` === "Ruby" ```ruby title="n_queens.rb" ### 回溯演算法：n 皇后 ### def backtrack(row, n, state, res, cols, diags1, diags2) # 當放置完所有行時，記錄解 if row == n res << state.map { |row| row.dup } return end # 走訪所有列 for col in 0...n # 計算該格子對應的主對角線和次對角線 diag1 = row - col + n - 1 diag2 = row + col # 剪枝：不允許該格子所在列、主對角線、次對角線上存在皇后 if !cols[col] && !diags1[diag1] && !diags2[diag2] # 嘗試：將皇后放置在該格子 state[row][col] = "Q" cols[col] = diags1[diag1] = diags2[diag2] = true # 放置下一行 backtrack(row + 1, n, state, res, cols, diags1, diags2) # 回退：將該格子恢復為空位 state[row][col] = "#" cols[col] = diags1[diag1] = diags2[diag2] = false end end end ### 求解 n 皇后 ### def n_queens(n) # 初始化 n*n 大小的棋盤，其中 'Q' 代表皇后，'#' 代表空位 state = Array.new(n) { Array.new(n, "#") } cols = Array.new(n, false) # 記錄列是否有皇后 diags1 = Array.new(2 * n - 1, false) # 記錄主對角線上是否有皇后 diags2 = Array.new(2 * n - 1, false) # 記錄次對角線上是否有皇后 res = [] backtrack(0, n, state, res, cols, diags1, diags2) res end ``` === "Zig" ```zig title="n_queens.zig" [class]{}-[func]{backtrack} [class]{}-[func]{nQueens} ``` ??? pythontutor "視覺化執行"

全螢幕觀看 >

逐行放置 $n$ 次，考慮列約束，則從第一行到最後一行分別有 $n$、$n-1$、$\dots$、$2$、$1$ 個選擇，使用 $O(n!)$ 時間。當記錄解時，需要複製矩陣 `state` 並新增進 `res` ，複製操作使用 $O(n^2)$ 時間。因此，**總體時間複雜度為 $O(n! \cdot n^2)$** 。實際上，根據對角線約束的剪枝也能夠大幅縮小搜尋空間，因而搜尋效率往往優於以上時間複雜度。陣列 `state` 使用 $O(n^2)$ 空間，陣列 `cols`、`diags1` 和 `diags2` 皆使用 $O(n)$ 空間。最大遞迴深度為 $n$ ，使用 $O(n)$ 堆疊幀空間。因此，**空間複雜度為 $O(n^2)$** 。