Leetcode - N-Queens

My code:

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

public class Solution {
    public List> solveNQueens(int n) {
        if (n <= 0)
            return null;
        ArrayList> ret = new ArrayList>();
        ArrayList queens = new ArrayList();
        boolean[][] isVisited = new boolean[n][n];
        helper(0, isVisited, ret, queens);
        return ret;
    }
    
    private boolean helper(int i, boolean[][] isVisited, 
            ArrayList> ret, ArrayList queens) {
        int row = isVisited.length;
        int col = isVisited.length;
        if (i >= row) {
            ret.add(new ArrayList(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> solveNQueens(int n) {
        List> ret = new ArrayList>();
        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> ret) {
        if (row >= n) {
            List group = new ArrayList();
            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

你可能感兴趣的:(Leetcode - N-Queens)