lintcode-33-N皇后问题

33-N皇后问题

n皇后问题是将n个皇后放置在n*n的棋盘上，皇后彼此之间不能相互攻击。

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

每个解决方案包含一个明确的n皇后放置布局，其中“Q”和“.”分别表示一个女王和一个空位置。

样例

对于4皇后问题存在两种解决的方案：

[

[".Q..", // Solution 1

"...Q",

"Q...",

"..Q."],

["..Q.", // Solution 2

"Q...",

"...Q",

".Q.."]

]

挑战

你能否不使用递归完成？

标签

递归 深度优先搜索

方法一：递归方式--回溯算法

1. 清空棋盘，rowIndex设为第一行，colIndex设为第一列

2. 判断棋盘上rowIndex、colIndex的位置是否满足条件(即保证经过这一点的行,列与斜对角线上都没有两个皇后)，
   
   若不满足，跳到第4步

3. 在rowIndex、colIndex的位置上满足条件的情形：

   • 在当前位置放一个皇后，若rowIndex是最后一行，记录一个解
   • 若rowIndex不是最后一行，rowIndex++, colIndex=0
   • 若rowIndex是最后一行，colIndex不是最后一列， colIndex++
   • 若rowIndex是最后一行，colIndex是最后一列，回溯，即清空当前行及以下各行的棋盘，然后，rowIndex--， colIndex=0
     
     以上返回到第2步

4. 在rowIndex、colIndex的位置上不满足条件的情形：

   • 若colIndex不是最后一列，colIndex设为下一列，返回到第2步
   • 若colIndex是最后一列了，回溯，即，若rowIndex行已经是第一行了，算法退出，否则，清空rowIndex及以下各行的棋盘，然后，rowIndex设为上一行，colIndex设为rowIndex的下一个待测位置，返回到第2步

把棋盘存储为一个N维数组a[N]，数组中第i个元素的值代表第i行的皇后位置，这样便可以把问题的空间规模压缩为一维O(N)，在判断是否冲突时也很简单，首先每行只有一个皇后，且在数组中只占据一个元素的位置，行冲突就不存在了，其次是列冲突，判断一下是否有a[i]与当前要放置皇后的列j相等即可。至于斜线冲突，通过观察可以发现所有在斜线上冲突的皇后的位置都有规律即它们所在的行列互减的绝对值相等，即| row – i | = | col – a[i] | 。这样某个位置是否可以放置皇后的问题已经解决。转自此博客

code

class Solution {
public:
    /**
     * Get all distinct N-Queen solutions
     * @param n: The number of queens
     * @return: All distinct solutions
     * For example, A string '...Q' shows a queen on forth position
     */
    vector<vector<string> > solveNQueens(int n) {
        // write your code here
        if(n == 1) {
            vector<vector<string> > result;
            vector<string> strOneRow;
            strOneRow.push_back("Q");
            result.push_back(strOneRow);
            return result;
        }
        else if(n < 4) {
            return vector<vector<string> > ();
        }

        vector<vector<string> > result;
        int i;

        int *pCheckerboard = new int[n];
        for(i=0; i<n; i++) {
            pCheckerboard[i] = -1;
        }

        queensRecursively(0, n, pCheckerboard, result);

        delete[] pCheckerboard;
        return result;
    }

    void queensRecursively(int row, int n, int *pCheckerboard, vector<vector<string> > &result) {
        int i = 0, j = 0;
        if(n == row) {
            vector<string> strOneRow;
            for(i=0; i<n; i++) {
                string str;
                for(j=0; j<n; j++) {
                    str += '.';
                }
                if(pCheckerboard[i]>=0 && pCheckerboard[i]<n) {
                    str[pCheckerboard[i]] = 'Q';
                }
                strOneRow.push_back(str);

            }
            result.push_back(strOneRow);
        }
        else {
            for(i=0; i<n; i++) {
                if(canPlace(row, i, n, pCheckerboard)) {
                    pCheckerboard[row] = i;
                    queensRecursively(row+1, n, pCheckerboard, result);
                }
            }
        }
    }

    int canPlace(int row, int col, int n, int *pCheckerboard) {
        int i;
        for(i=0; i<n && i!=row; i++) {
            if(pCheckerboard[i] == col) {
                return 0;
            }
            if(abs(row-i) == abs(col-pCheckerboard[i])) {
                return 0;
            }
        }
        return 1;
    }
};

方法二：非递归

非递归方法的一个重要问题时何时回溯及如何回溯的问题。程序首先对N行中的每一行进行探测，寻找该行中可以放置皇后的位置，具体方法是对该行的每一列进行探测，看是否可以放置皇后，如果可以，则在该列放置一个皇后，然后继续探测下一行的皇后位置。如果已经探测完所有的列都没有找到可以放置皇后的列，此时就应该回溯，把上一行皇后的位置往后移一列，如果上一行皇后移动后也找不到位置，则继续回溯直至某一行找到皇后的位置或回溯到第一行，如果第一行皇后也无法找到可以放置皇后的位置，则说明已经找到所有的解程序终止。如果该行已经是最后一行，则探测完该行后，如果找到放置皇后的位置，则说明找到一个结果，打印出来。但是此时并不能再此处结束程序，因为我们要找的是所有N皇后问题所有的解，此时应该清除该行的皇后，从当前放置皇后列数的下一列继续探测。转自此博客

code

class Solution {
public:
    /**
     * Get all distinct N-Queen solutions
     * @param n: The number of queens
     * @return: All distinct solutions
     * For example, A string '...Q' shows a queen on forth position
     */
    vector<vector<string> > solveNQueens(int n) {
        // write your code here
        if(n == 1) {
            vector<vector<string> > result;
            vector<string> strOneRow;
            strOneRow.push_back("Q");
            result.push_back(strOneRow);
            return result;
        }
        else if(n < 4) {
            return vector<vector<string> > ();
        }

        vector<vector<string> > result;
        int i=0, row=0, col=0, j=0, k=0;
        int *pCheckerboard = new int[n];
        for(i=0; i<n; i++) {
            pCheckerboard[i] = -1;
        }

        while(row < n) {
            while(col < n) {
                if(canPlace(row, col, n, pCheckerboard)) {
                    pCheckerboard[row] = col;
                    col = 0;
                    break;
                }
                else {
                    col++;
                }
            }

            if(pCheckerboard[row] == -1) {
                if(row == 0) {
                    break;
                }
                else {
                    row--;
                    col = pCheckerboard[row] + 1;
                    pCheckerboard[row] = -1;
                    continue;
                }
            }

            if(row == n-1) {
                vector<string> strOneRow;
                for(k=0; k<n; k++) {
                    string str;
                    for(j=0; j<n; j++) {
                        str += '.';
                    }
                    if(pCheckerboard[k]>=0 && pCheckerboard[k]<n) {
                        str[pCheckerboard[k]] = 'Q';
                    }
                    strOneRow.push_back(str);

                }
                result.push_back(strOneRow);

                col = pCheckerboard[row] + 1;
                pCheckerboard[row] = -1;
                continue;
            }
            row++;
        }
        delete[] pCheckerboard;
        return result;
    }

    int canPlace(int row, int col, int n, int *pCheckerboard) {
        int i;
        for(i=0; i<n && i!=row; i++) {
            if(pCheckerboard[i] == col) {
                return 0;
            }
            if(abs(row-i) == abs(col-pCheckerboard[i])) {
                return 0;
            }
        }
        return 1;
    }
};