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
