My code:

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<List<String>> solveNQueens(int n) {
        if (n <= 0)
            return null;
        ArrayList<List<String>> ret = new ArrayList<List<String>>();
        ArrayList<String> queens = new ArrayList<String>();
        boolean[][] isVisited = new boolean[n][n];
        helper(0, isVisited, ret, queens);
        return ret;
    }
    
    private boolean helper(int i, boolean[][] isVisited, 
            ArrayList<List<String>> ret, ArrayList<String> queens) {
        int row = isVisited.length;
        int col = isVisited.length;
        if (i >= row) {
            ret.add(new ArrayList<String>(queens));
            return true;
        }
        else {
            boolean isQueen = false;
            
            for (int k = 0; k < col; k++) {
                if (!isVisited[i][k]) {
                    boolean[][] isVisitedCurr = visit(i, k, isVisited);
                    String queen = formString(k, col);
                    queens.add(queen);
                    isQueen |= helper(i + 1, isVisitedCurr, ret, queens);
                    queens.remove(queens.size() - 1);
                }
            }
            return isQueen;
        }
    }
    
    private boolean[][] visit(int i, int j, boolean[][] isVisitedOld) {
        int row = isVisitedOld.length;
        int col = isVisitedOld.length;
        boolean[][] isVisited = new boolean[row][col];
        for (int m = 0; m < row; m++)
            for (int n = 0; n < col; n++)
                isVisited[m][n] = isVisitedOld[m][n];
        isVisited[i][j] = true;
        int left = j - 1;
        while (left >= 0)
            isVisited[i][left--] = true;
        int right = j + 1;
        while (right < col)
            isVisited[i][right++] = true;
        int up = i - 1;
        while (up >= 0)
            isVisited[up--][j] = true;
        int down = i + 1;
        while (down < row)
            isVisited[down++][j] = true;
        int leftUp = 1;
        while (i - leftUp >= 0 && j - leftUp >= 0) {
            isVisited[i - leftUp][j - leftUp] = true;
            leftUp++;
        }
        int rightUp = 1;
        while (i - rightUp >= 0 && j + rightUp < col) {
            isVisited[i - rightUp][j + rightUp] = true;
            rightUp++;
        }
        int leftDown = 1;
        while (i + leftDown < row && j - leftDown >= 0) {
            isVisited[i + leftDown][j - leftDown] = true;
            leftDown++;
        }
        int rightDown = 1;
        while (i + rightDown < row && j + rightDown < col) {
            isVisited[i + rightDown][j + rightDown] = true;
            rightDown++;
        }
        return isVisited;
    }
    
    private String formString(int k, int col) {
        String queen = "";
        for (int i = 0; i < k; i++)
            queen += ".";
        queen += "Q";
        for (int i = k + 1; i < col; i++)
            queen += ".";
        return queen;
    }
    
    public static void main(String[] args) {
        Solution test = new Solution();
        System.out.println(test.solveNQueens(2));
    }
}

基本一遍过了N皇后。。。
感觉自己强暴了。。。。
爆炸了。。。
感觉这道题目的思想还是DFS，permutation 那一类题目，只不过形式夸张了一些。
就如同那道面试题，求质数的次方和。。。都是换个形式。
所以这种需要你求出多种变化，多种结果，然后存在一个容器里面的，一般都是这个思路。
具体思路我也不想说了。我想我不会忘记。

**
总结： permutation, dfs
**

Anyway, Good luck, Richardo!

My code:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> ret = new ArrayList<List<String>>();
        if (n <= 0) {
            return ret;
        }
        
        helper(0, new boolean[n], new boolean[2 * n], new boolean[2 * n], new String[n], n, ret);
        return ret;
    }
    
    private void helper(int row, boolean[] col, boolean[] l1, boolean[] l2, String[] board, int n, List<List<String>> ret) {
        if (row >= n) {
            List<String> group = new ArrayList<String>();
            for (String s : board) {
                group.add(s);
            }
            ret.add(group);
            return;
        }
        for (int i = 0; i < n; i++) {
            int index1 = row - i + n;
            int index2 = 2 * n - i - row - 1;
            if (!col[i] && !l1[index1] && !l2[index2]) {
                col[i] = true;
                l1[index1] = true;
                l2[index2] = true;
                char[] level = new char[n];
                Arrays.fill(level, '.');
                level[i] = 'Q';
                board[row] = String.valueOf(level);
                helper(row + 1, col, l1, l2, board, n, ret);
                col[i] = false;
                l1[index1] = false;
                l2[index2] = false;
            }
        }
    }
}

以前的做法，太复杂了，虽然思路没怎么变。
网上看了答案，感觉是真的简洁。
reference:
https://discuss.leetcode.com/topic/8592/comparably-concise-java-code

我一直在思考一个问题：
backtracking 的时候，我给某个位置放个皇后，我得把用来记录状态的 isVisited[][] 相关区域全部设置成true
之后回到这一层，再把它恢复过来。但恢复过来是不可能的，因为你可能把别的皇后做成的true转换成false
唯一的解决方法，就是每次dfs的时候，都拷贝一份isVisited[][] 下去，然后上来的时候就不用再恢复了。
但这个很花空间，花时间。

问题就在于，皇后占着一个位置，行列我都可以轻松地拿一维数组来mark，但是斜方向的两条线，我无法用数组来衡量。
其实是有的

仔细观察，对于斜率小于0的那条线。

i – j, 同一条线上的，永远是定值，不同线上的，值都不同。
当然， i – j 可能 < 0,所以， 为了可以用数组来表示，统一加上 n
于是，数组中的index = i – j + n

斜率小于0的那条线
n – col – row – 1 是定值，为了让他大于0
所以index = 2 * n – col – row – 1
这样每次backtracking,下去的时候就把他们置成true,回来的时候，很轻松地置成false。之后的问题就简单了。就是简单地一个backtracking

已经见过好几次利用一个数就能标志一条线的例子了。
比如
Max point on a line
利用 (y2 – y1) / (x2 – x1) = (y3 – y1) / (x3 – x1)
和 最大公约数，找出一条直线的代表数字

比如这道题目， n * n 里面，表示一条对称线的方法。

Anyway, Good luck, Richardo! — 09/23/2016