Moderate algorithm | 33. N Queens Problem

Title Description

n is an n-queens problem queens n * n placed on the board, can not attack each other Queen each other (any two Queens not in the same row, same column, the same oblique lines).

Given an integer n, returns all solutions to different problems of the Queen of n.

Each solution includes placing a clear layout Queen n, wherein "Q" and "." Respectively represent one queen and one empty position.

Sample 1

输入:1
输出:
   [["Q"]]

Sample 2

输入:4
输出:
[
  // Solution 1
  [".Q..",
   "...Q",
   "Q...",
   "..Q."
  ],
  // Solution 2
  ["..Q.",
   "Q...",
   "...Q",
   ".Q.."
  ]
]

java solution to a problem

Search violence, try to place can be placed, each program can return

class Solution {
    List<List<String>> solveNQueens(int n) {
        List<List<String>> results = new ArrayList<>();
        if (n <= 0) {
            return results;
        }
        
        search(results, new ArrayList<Integer>(), n);
        return results;
    }
    
    /*
     * results store all of the chessboards
     * cols store the column indices for each row
     */
    private void search(List<List<String>> results,
                        List<Integer> cols,
                        int n) {
        if (cols.size() == n) {
            results.add(drawChessboard(cols));
            return;
        }
        
        for (int colIndex = 0; colIndex < n; colIndex++) {
            if (!isValid(cols, colIndex)) {
                continue;
            }
            cols.add(colIndex);
            search(results, cols, n);
            cols.remove(cols.size() - 1);
        }
    }
    
    private List<String> drawChessboard(List<Integer> cols) {
        List<String> chessboard = new ArrayList<>();
        for (int i = 0; i < cols.size(); i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < cols.size(); j++) {
                sb.append(j == cols.get(i) ? 'Q' : '.');
            }
            chessboard.add(sb.toString());
        }
        return chessboard;
    }
    
    private boolean isValid(List<Integer> cols, int column) {
        int row = cols.size();
        for (int rowIndex = 0; rowIndex < cols.size(); rowIndex++) {
            if (cols.get(rowIndex) == column) {
                return false;
            }
            if (rowIndex + cols.get(rowIndex) == row + column) {
                return false;
            }
            if (rowIndex - cols.get(rowIndex) == row - column) {
                return false;
            }
        }
        return true;
    }
}

C ++ solution to a problem

Search violence, try to place can be placed, each program can return

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
        // write your code here
        vector<vector<string> > result;
        if( n <= 0 )
        {
            return result;
        }
        vector<int> cols;
        search(n, cols, result);
        return result;
    }
    
    void search(int n, vector<int> &cols, vector<vector<string> > &result)
    {
        if(cols.size() == n)
        {
            result.push_back(drawResult(cols, n));
            return;
        }
        for(int col = 0; col < n; col++)
        {
            if(!isValid(cols, col))
            {
                continue;
            }
            cols.push_back(col);
            search(n, cols, result);
            cols.pop_back();
        }
    }
    bool isValid(vector<int> &cols, int col)
    {
        int row = cols.size();
        for(int i = 0; i < row; ++i)
        {
            if(cols[i] == col)
            {
                return false;
            }
            if(i - cols[i] == row - col)
            {
                return false;
            }
            if(i + cols[i] == row + col)
            {
                return false;
            }
        }
        return true;
    }
    
    vector<string> drawResult(vector<int> &cols, int n)
    {
        vector<string> result;
        for(int i = 0; i < cols.size(); ++i)
        {
            string temp(n, '.');
            temp[cols[i]] = 'Q';
            result.push_back(temp);
        }
        return result;
    }
};

python problem solution

Type arrangement with a depth-first search algorithm.

class Solution:
    def solveNQueens(self, n):
        results = []
        self.search(n, [], results)
        return results
        
    def search(self, n, cols, results):
        row = len(cols)
        if row == n:
            results.append(self.draw_chessboard(cols))
            return

        for col in range(n):
            if not self.is_valid(cols, row, col):
                continue
            cols.append(col)
            self.search(n, cols, results)
            cols.pop()
            
    def draw_chessboard(self, cols):
        n = len(cols)
        board = []
        for i in range(n):
            row = ['Q' if j == cols[i] else '.' for j in range(n)]
            board.append(''.join(row))
        return board
        
    def is_valid(self, cols, row, col):
        for r, c in enumerate(cols):
            if c == col:
                return False
            if r - c == row - col or r + c == row + col:
                return False
        return True