O(n)空间中的N个皇后

在这个问题中，我们需要在一个n x n的棋盘上放置N个皇后，使得它们互相不能攻击到对方。换句话说，两个皇后不能在同一行、同一列或同一对角线上。

算法思路

对于这个问题，我们可以采用回溯算法，通过不断尝试不同的解决方案来得到有效的解。

具体来说，我们可以采用一个一维数组cols来表示每一行中皇后的位置，也就是cols[i]表示第i行的皇后所在的列数。然后，我们可以不断地在每一行中放置一个皇后，直到所有的皇后都已被安置。

在递归的代码实现中，我们需要在每一行中枚举所有的列数，判断当前位置是否可以安放皇后。如果可以，我们就将皇后的位置记录在cols数组中，并递归地尝试下一行。 如果在某一行中不能安放皇后，则需要回溯到上一行，尝试其他列的位置。

代码实现

以下是该问题的Python实现：

def solveNQueens(n: int) -> List[List[str]]:
    def backtrack(row: int) -> None:
        nonlocal result
        if row == n:
            board = []
            for i in range(n):
                row_str = ""
                for j in range(n):
                    row_str += "Q" if j == cols[i] else "."
                board.append(row_str)
            result.append(board)
        else:
            for col in range(n):
                if col in col_set or row - col in diag_set or row + col in anti_diag_set:
                    continue
                cols[row] = col
                col_set.add(col)
                diag_set.add(row - col)
                anti_diag_set.add(row + col)
                backtrack(row + 1)
                cols[row] = -1
                col_set.remove(col)
                diag_set.remove(row - col)
                anti_diag_set.remove(row + col)

    result = []
    cols = [-1] * n
    col_set = set()
    diag_set = set()
    anti_diag_set = set()
    backtrack(0)
    return result

时间复杂度

该算法的时间复杂度为O(n!)，因为我们需要枚举所有的皇后排列情况，但是其中大部分情况都不符合要求，因此实际运行时间要远远低于n!。同时，由于我们只使用了一维数组来存储皇后位置，因此空间复杂度为O(n)。