LeetCode（51）：N皇后

Hard！

題目描述：

n 皇后問題研究的是如何將 n 個皇后放置在 n×n 的棋盤上，並且使皇后彼此之間不能相互攻擊。

上圖為 8 皇后問題的一種解法。

給定一個整數 n，返回所有不同的 n 皇后問題的解決方案。

每一種解法包含一個明確的 n 皇后問題的棋子放置方案，該方案中 'Q' 和 '.' 分別代表了皇后和空位。

示例:

輸入: 4
輸出: [
 [".Q..",  // 解法 1
  "...Q",
  "Q...",
  "..Q."],

 ["..Q.",  // 解法 2
  "Q...",
  "...Q",
  ".Q.."]
]
解釋: 4 皇后問題存在兩個不同的解法。

解題思路：

經典的N皇后問題，基本所有的算法書中都會包含的問題，經典解法為回溯遞歸，一層一層的向下掃描，需要用到一個pos數組，其中pos[i]表示第i行皇后的位置，初始化為-1，然后從第0開始遞歸，每一行都依次遍歷各列，判斷如果在該位置放置皇后會不會有沖突，以此類推，當到最后一行的皇后放好后，一種解法就生成了，將其存入結果res中，然后再繼續完成搜索剩余所有的情況。

C++解法一：

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
        vector<vector<string> > res;
        vector<int> pos(n, -1);
        solveNQueensDFS(pos, 0, res);
        return res;
    }
    void solveNQueensDFS(vector<int> &pos, int row, vector<vector<string> > &res) {
        int n = pos.size();
        if (row == n) {
            vector<string> out(n, string(n, '.'));
            for (int i = 0; i < n; ++i) {
                out[i][pos[i]] = 'Q';
            }
            res.push_back(out);
        } else {
            for (int col = 0; col < n; ++col) {
                if (isValid(pos, row ,col)) {
                    pos[row] = col;
                    solveNQueensDFS(pos, row + 1, res);
                    pos[row] = -1;
                }
            }
        }
    }
    bool isValid(vector<int> &pos, int row, int col) {
        for (int i = 0; i < row; ++i) {
            if (col == pos[i] || abs(row - i) == abs(col - pos[i])) {
                return false;
            }
        }
        return true;
    }
};

這種棋盤類的題目一般是回溯法, 依次放置每行的皇后。在放置的時候，要保持當前的狀態為合法，即當前放置位置的同一行、同一列、兩條對角線上都不存在皇后。

C++解法二：

class Solution {
private:
    vector<vector<string> > res;
public:
    vector<vector<string> > solveNQueens(int n) {
        vector<string>cur(n, string(n,'.'));
        helper(cur, 0);
        return res;
    }
    void helper(vector<string> &cur, int row)
    {
        if(row == cur.size())
        {
            res.push_back(cur);
            return;
        }
        for(int col = 0; col < cur.size(); col++)
            if(isValid(cur, row, col))
            {
                cur[row][col] = 'Q';
                helper(cur, row+1);
                cur[row][col] = '.';
            }
    }
     
    //判斷在cur[row][col]位置放一個皇后，是否是合法的狀態
    //已經保證了每行一個皇后，只需要判斷列是否合法以及對角線是否合法。
    bool isValid(vector<string> &cur, int row, int col)
    {
        //列
        for(int i = 0; i < row; i++)
            if(cur[i][col] == 'Q')return false;
        //右對角線(只需要判斷對角線上半部分，因為后面的行還沒有開始放置)
        for(int i = row-1, j=col-1; i >= 0 && j >= 0; i--,j--)
            if(cur[i][j] == 'Q')return false;
        //左對角線(只需要判斷對角線上半部分，因為后面的行還沒有開始放置)
        for(int i = row-1, j=col+1; i >= 0 && j < cur.size(); i--,j++)
            if(cur[i][j] == 'Q')return false;
        return true;
    }
};

上述判斷狀態是否合法的函數還是略復雜，其實只需要用一個一位數組來存放當前皇后的狀態。假設數組為int state[n], state[i]表示第 i 行皇后所在的列。那么在新的一行 k 放置一個皇后后:

• 判斷列是否沖突，只需要看state數組中state[0…k-1] 是否有和state[k]相等；
• 判斷對角線是否沖突：如果兩個皇后在同一對角線，那么|row1-row2| = |column1 - column2|，（row1，column1），（row2，column2）分別為沖突的兩個皇后的位置

C++解法三：

class Solution {
private:
    vector<vector<string> > res;
public:
    vector<vector<string> > solveNQueens(int n) {
        vector<int> state(n, -1);
        helper(state, 0);
        return res;
    }
    void helper(vector<int> &state, int row)
    {//放置第row行的皇后
        int n = state.size();
        if(row == n)
        {
            vector<string>tmpres(n, string(n,'.'));
            for(int i = 0; i < n; i++)
                tmpres[i][state[i]] = 'Q';
            res.push_back(tmpres);
            return;
        }
        for(int col = 0; col < n; col++)
            if(isValid(state, row, col))
            {
                state[row] = col;
                helper(state, row+1);
                state[row] = -1;;
            }
    }
     
    //判斷在row行col列位置放一個皇后，是否是合法的狀態
    //已經保證了每行一個皇后，只需要判斷列是否合法以及對角線是否合法。
    bool isValid(vector<int> &state, int row, int col)
    {
        for(int i = 0; i < row; i++)//只需要判斷row前面的行，因為后面的行還沒有放置
            if(state[i] == col || abs(row - i) == abs(col - state[i]))
                return false;
        return true;
    }
};

C++解法四（解法三的非遞歸版）：

class Solution {
private:
    vector<vector<string> > res;
public:
    vector<vector<string> > solveNQueens(int n) {
        vector<int> state(n, -1);
        for(int row = 0, col; ;)
        {
            for(col = state[row] + 1; col < n; col++)//從上一次放置的位置后面開始放置
            {
                if(isValid(state, row, col))
                {
                    state[row] = col;
                    if(row == n-1)//找到了一個解,繼續試探下一列
                    {
                        vector<string>tmpres(n, string(n,'.'));
                        for(int i = 0; i < n; i++)
                            tmpres[i][state[i]] = 'Q';
                        res.push_back(tmpres);
                    }
                    else {row++; break;}//當前狀態合法，去放置下一行的皇后
                }
            }
            if(col == n)//當前行的所有位置都嘗試過，回溯到上一行
            {
                if(row == 0)break;//所有狀態嘗試完畢，退出
                state[row] = -1;//回溯前清除當前行的狀態
                row--;
            }
        }
        return res;
    }
     
    //判斷在row行col列位置放一個皇后，是否是合法的狀態
    //已經保證了每行一個皇后，只需要判斷列是否合法以及對角線是否合法。
    bool isValid(vector<int> &state, int row, int col)
    {
        for(int i = 0; i < row; i++)//只需要判斷row前面的行，因為后面的行還沒有放置
            if(state[i] == col || abs(row - i) == abs(col - state[i]))
                return false;
        return true;
    }
};

下面還有一個算法，這個算法主要參考：https://blog.csdn.net/hackbuteer1/article/details/6657109。看helper函數，參數row、ld、rd分別表示在列和兩個對角線方向的限制條件下，當前行的哪些地方不能放置皇后。如下圖

 

前三行放置了皇后，他們對第3行（行從0開始）的影響如下：                            

（1）列限制條件下，第3行的0、2、4列（紫色線和第3行的交點）不能放皇后，因此row = 101010

（2）左對角線限制條件下，第3行的0、3列（藍色線和第3行的交點）不能放皇后，因此ld = 100100

（3）右對角線限制條件下，第3行的3、4、5列（綠色線和第3行的交點）不能放皇后，因此rd = 000111

~(row | ld | rd) = 010000，即第三行只有第1列能放置皇后。

在3行1列這個位置放上皇后，row，ld，rd對下一行的影響為：

row的第一位置1，變為111010

ld的第一位置1，並且向左移1位（因為左對角線對行的影響是依次向左傾斜的），變為101000

rd的第一位置1，並且向右移1位（因為右對角線對行的影響是依次向右傾斜的），變為001011

第4行狀態如下圖

 

C++解法五（這應該是最高效的算法了）：

class Solution {
private:
    vector<vector<string> > res;
    int upperlim;
public:
    vector<vector<string> > solveNQueens(int n) {
        upperlim = (1 << n) - 1;//低n位全部置1
        vector<string> cur(n, string(n, '.'));
        helper(0,0,0,cur,0);
        return res;
    }
     
    void helper(const int row, const int ld, const int rd, vector<string>&cur, const int index)
    {
        int pos, p;
        if ( row != upperlim )
        {
            pos = upperlim & (~(row | ld | rd ));//pos中二進制為1的位，表示可以在當前行的對應列放皇后
            //和upperlim與運算，主要是ld在上一層是通過左移位得到的，它的高位可能有無效的1存在，這樣會清除ld高位無效的1
            while ( pos )
            {
                p = pos & (~pos + 1);//獲取pos最右邊的1,例如pos = 010110，則p = 000010
                pos = pos - p;//pos最右邊的1清0
                setQueen(cur, index, p, 'Q');//在當前行，p中1對應的列放置皇后
                helper(row | p, (ld | p) << 1, (rd | p) >> 1, cur, index+1);//設置下一行
                setQueen(cur, index, p, '.');
            }
        }
        else//找到一個解
            res.push_back(cur);
    }
     
    //第row行，第loc1(p)列的位置放置一個queen或者清空queen，loc1(p)表示p中二進制1的位置
    void setQueen(vector<string>&cur, const int row, int p, char val)
    {
        int col = 0;
        while(!(p & 1))
        {
            p >>= 1;
            col++;
        }
        cur[row][col] = val;
    }
};