51. N皇后

题目：
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。

n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

示例：

输入：n = 4
输出：[[“.Q…”,“…Q”,“Q…”,“…Q.”],[“…Q.”,“Q…”,“…Q”,“.Q…”]]

解题思路：
这道题我们让求得就是皇后放置的位置，用path来记录每行的皇后放置在哪一列，有了path我们便可以构造出答案。由于列号不能相同，其实就相当于是在做列号的全排列。
现在来看约束条件：
1、我们是递归地选择每一行的位置，那么皇后就不可能在同一行。
2、我们是对列号做全排列，所以列号就不会相同，皇后也不会在同一列。
现在就需要判断皇后的位置时候在同一斜线。需要注意的是斜线有两种情况： ↗ 方向和 ↖方向。
对于↗ 方向，如果两个点的行号+列号相等，则两个点位于↗方向的同一斜线。
对于 ↖方向，如果两个点的行号-列号相等，则两个点位于↖方向的同一斜线。

class Solution {
    private List<List<String>> result = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        boolean[] used = new boolean[n];
        backtrack(n, used);
        return result;
    }

    private void backtrack(int n, boolean[] used) {
        if (!isValid(path)) {
            return;
        }
        if (path.size() == n) {
            List<String> res = new ArrayList<>();
            for (int pos : path) {
                char[] ch = new char[n];
                Arrays.fill(ch, '.');
                ch[pos] = 'Q';
                res.add(new String(ch));
            }
            result.add(res);
            return;
        }
        for (int i = 0; i < n; i++) {
            if (!used[i]) {
                path.add(i);
                used[i] = true;
                backtrack(n, used);
                path.removeLast();
                used[i] = false;
            }

        }
    }

    private boolean isValid(List<Integer> path) {
        for (int i = 0; i < path.size(); i++) {
            for (int j = i + 1; j < path.size(); j++) {
                // 在/方向的斜线，行号+列号相等
                if (i + path.get(i) == j + path.get(j)) {
                    return false;
                }
                // 在\方向的斜线，行号-列号相等
                if (i - path.get(i) == j - path.get(j)) {
                    return false;
                }
            }
        }
        return true;
    }
}

优化：
上述方法主要时间瓶颈是判断斜线上，如果我们将每条斜线上是否有皇后放置的信息存放到一个bool数组里面，那么我们就可以在O(1)的时间内判断出结果。
对于n*n的二维数组，一共有2n-1条↗斜线，每条斜线的行号+列号都是相等的，并且每条斜线的值依次从0到2n-2递增，所以bool数组的每个元素就对应一条↗斜线。
同样也有2n-1条↖斜线，每条斜线的行号-列号是相等的，但是值是从-(n-1),-(n-2)…0,1,2,n-1，所以不能直接映射到bool数组的下标，需要先将行号-列号的值+(n-1)，从而将每条斜线的值映射到0到2n-2。

class Solution {
    private List<List<String>> result = new ArrayList<>();
    private List<Integer> path = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        boolean[] used = new boolean[n];
        boolean[] diag1 = new boolean[2*n - 1];
        boolean[] diag2 = new boolean[2*n - 1];
        backtrack(n, 0, used, diag1, diag2);
        return result;
    }

    private void backtrack(int n, int r, boolean[] used, boolean[] diag1, boolean[] diag2) {
        if (r == n) {
            List<String> res = new ArrayList<>();
            for (int c : path) {
                char[] row = new char[n];
                Arrays.fill(row, '.');
                row[c] = 'Q';
                res.add(new String(row));
            }
            result.add(res);
            return;
        }
        for (int c = 0; c < n; c++) {
            int rc = r - c + n - 1;
            if (!used[c] && !diag1[r + c] && !diag2[rc]) {
                path.add(c);
                used[c] = diag1[r + c] = diag2[rc] = true;
                backtrack(n, r + 1, used, diag1, diag2);
                path.removeLast();
                used[c] = diag1[r + c] = diag2[rc] = false;
            }

        }
    }
}