N-Queens

The n-queens puzzle is the problem of placing n queens on an n�n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

For example,
There exist two distinct solutions to the 4-queens puzzle:

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

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

方法一：递归 + 回溯

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        vector<vector<string> > ret;
        vector<string> sol(n,string(n,'.'));
        vector<int> A(n,-1);
        putQueens(0,n,sol,ret,A);
    	return ret;
    }
    
    
    void putQueens(int i,int n,vector<string> &sol,vector<vector<string>> &ret, vector<int> &A)
    {
        if(i == n) {
            ret.push_back(sol);
            sol[n-1][A[n-1]] = '.';
            return;
        }
		
        for(int j = 0; j < n;j++)
        {
            int flag = 1;
            for(int k = 0;k < n;k++)
            {
                if(sol[k][j] == 'Q' || sol[i][k] == 'Q'||(i+j-k >=0 && i+j-k < n && sol[k][i+j-k] == 'Q')||
					(i-j+k >= 0  && i-j+k < n && sol[i-j+k][k] == 'Q'))
                {
                    flag = 0;
                    break;
                }
				
            }   
            if(flag){
                sol[i][j] = 'Q';
                A[i] = j;
                putQueens(i+1,n,sol,ret,A);
            }
        }
    
        if(i == 0  && A[0] == n-1) return;
        sol[i-1][A[i-1]] = '.';
        return; 
    }
};

56 milli secs

方法二：不使用递归只用回溯的做法

class Solution {
public:
    bool check(vector<string>& matrix,int i,int j)
    {
		int n = matrix.size();
        for(int k = 0;k < n ;k++)
        {
            if(matrix[i][k] == 'Q' || matrix[k][j] == 'Q') return false;
			int i1 = i-j+k ,i2 = i+j-k;
			if(i1 >=0 && i1 < n && matrix[i1][k] == 'Q') return false;
			if(i2 >= 0 && i2 < n && matrix[i2][k] == 'Q') return false;
        }
		return true;
    }
    
    vector<vector<string> > solveNQueens(int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int i = 0,j = 0;
        string s(n,'.');
        vector<string> matrix(n,s);
        vector<vector<string>> ret;
        vector<int> vec(n,-1);
        bool flag = true;
        while(true)
        {
            if(i == matrix.size()){
                vector<string> temp(matrix);
                ret.push_back(temp);
                matrix[i-1][vec[i-1]] = '.';
                i--;
                j = vec[i]+1;
            }else if(j == matrix.size()){
                if(i == matrix.size()-1){
					flag = false;
				}
				if(!flag && i == 0) break;

                matrix[i-1][vec[i-1]] = '.';
				i--;
                j = vec[i]+1;
            }else if(check(matrix,i,j)){
                matrix[i][j] = 'Q';
                vec[i] = j;
                i++;
				j = 0;
            }else {
                j++;
            }
        }
		return ret;
    }
};

64 milli secs.

应该可以利用对称性减少计算量。

另外看到有用位运算提高速度的算法，回头看一下

http://java-mans.iteye.com/blog/1648510