Algorithms : N-Queens problem with BackTracking Algorithms

最新推荐文章于 2024-09-08 07:46:39 发布

sesiria

最新推荐文章于 2024-09-08 07:46:39 发布

阅读量166

点赞数

分类专栏： C++ Algorithm 文章标签：回溯算法递归算法 N皇后问题

本文链接：https://blog.csdn.net/sesiria/article/details/100735441

版权

C++ 同时被 2 个专栏收录

62 篇文章 1 订阅

订阅专栏

Algorithm

53 篇文章 0 订阅

订阅专栏

N皇后问题要求在n×n棋盘上放置n个皇后，使得它们互不攻击。给定一个整数n，返回n皇后问题的不同解决方案数量。例如，当n为4时，有两个不同解。时间复杂度为O(n!)，本文探讨了使用回溯算法解决此问题的方法。

摘要由CSDN通过智能技术生成

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 the number of distinct solutions to the n-queens puzzle.

Input: 4
Output: 2
Explanation: There are two distinct solutions to the 4-queens puzzle as shown below.
[
[".Q..", // Solution 1
  "...Q",
  "Q...",
  "..Q."],

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

class Solution {
private:
    bool checkConflict(int row, int col, vector<int> & columns) {
        for (int r = 0; r < row; ++r) {
            // a the same column of at the diagonal
            if(columns[r] == col || row - r == abs(columns[r] - col))
                return false;
        }
        return true;
    }
    
    void backTracking(int row, int n, vector<int>& columns, int & count) {
        if(row == n) {
            count++;
            return;
        }
        
        // try to place che queen in the current row and check whether
        // it is valid.
        for(int col = 0; col < n; ++col) {
            columns[row] = col;
            
            if(checkConflict(row, col, columns))
                backTracking(row + 1, n, columns, count);
            
            columns[row] = -1;
        }
    }
public:
    int totalNQueens(int n) {
        int count = 0;
        vector<int> columns(n, 0);
        backTracking(0, n, columns, count);
        return count;
    }
};

The Time complexity

Assume T(N) is the time complexity for N Queen problem

It neet n*T(n-1) +n*n.

That is T(n) = n*T(n-1) +n^2

then T(n) = n*(n-1)*T(n-2) + n^2 + n*(n-1)^2

...T(n) = n*(n-1)*(n-2)*...*T(0) + = O(n!)

A final test solution：

#include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <string>
#include <vector>
#include <stack>

using namespace std;

class Solution {
private:
    bool checkConflict(int row, int col, vector<int> & columns) {
        for (int r = 0; r < row; ++r) {
            // a the same column of at the diagonal
            if(columns[r] == col || row - r == abs(columns[r] - col))
                return false;
        }
        return true;
    }
    
    void backTracking(int row, int n, vector<int>& columns, 
                      vector<vector<int>> & results) {
        if(row == n) {
            results.push_back(columns);
            return;
        }
        
        // try to place che queen in the current row and check whether
        // it is valid.
        for(int col = 0; col < n; ++col) {
            columns[row] = col;
            
            if(checkConflict(row, col, columns)) {
                backTracking(row + 1, n, columns, results);
            }
            
            columns[row] = -1;
        }
    }
public:
    vector<vector<int>> totalNQueens(int n) {
        vector<vector<int>> results;
        vector<int> columns(n, 0);
        backTracking(0, n, columns, results);
        return results;
    }

    void printQueen(int pos, int Total) {
        for(int i = 0; i < Total; ++i) {
            cout << (i == pos ? 'X' : ' ');
        }
        cout << endl;
    }
    void printResult(vector<vector<int>> & results) {
        for(auto & solution : results) {
            cout << "-----------------------------" << endl;
            int n = solution.size();
            for(int i = 0; i < n; ++i)
                printQueen(solution[i], n);
            cout << "-----------------------------" << endl;
        }
    }
};

int main()
{
    Solution sol;

    auto result = sol.totalNQueens(5);
    sol.printResult(result);
    return 0;
}