leetcode51. N皇后（参考算法笔记)

最新推荐文章于 2022-07-08 04:31:52 发布

不贰Kennan

最新推荐文章于 2022-07-08 04:31:52 发布

阅读量193

点赞数

分类专栏：算法题文章标签： leetcode 算法

本文链接：https://blog.csdn.net/qq_28805597/article/details/104985441

版权

算法题专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文介绍了LeetCode第51题——N皇后问题的两种解法。首先介绍了暴力枚举的思路，该方法通过递归枚举所有可能的排列，但时间复杂度较高。接着详细讲解了回溯法（剪枝）的解决方案，利用回溯策略在遇到冲突时及时回溯，降低计算量，提高效率。

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

问题描述

在这里插入图片描述
链接：leetcode 51

我的解法

在这里插入图片描述

方法一：暴力枚举

思路参考DFS（递归枚举所有排列，复杂度为O(N2）)

class Solution {
public:
    bool hash[10]={false};
    int p[10]={0};
    void solve(vector<vector<string>> &result,int &n, int index){
        //边界判断
        if(index==n+1){
            //flag判断当前排列合法
            bool flag=true;
			//此处的循环意思是，检查已有的排列是不是合法
            for(int i=1;i<=n;i++){
                for(int j=i+1;j<=n;j++){
                    if(abs(i-j)==abs(p[i]-p[j])){
                        flag=false;
                    }
                }
            }
            if(flag){
                //此时p[]为n列皇后所在的行号
                vector<string> res;
                for(int j=1;j<index;j++){
                    string s;
                    for(int i=1;i<index;i++){
                        if(i!=p[j]){
                            s.append(".");
                        }else{
                            s.append("Q");
                        }
                    }
                    res.push_back(s);
                }
                
                result.push_back(res);
            }
            return;
        }
        for(int i=1;i<=n;i++){
            if(hash[i]==false){
				//此处不管i放在p[index]合不合法，先放上再说
                p[index]=i;
                hash[i]=true;
                solve(result,n,index+1);
                hash[i]=false;
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> result;
        solve(result,n,1);
        return result;
    }
};

方法二：回溯法（剪枝）

回溯法，或者说是DFS的剪枝算法，如果某种情况到某个深度时已经冲突，则直接回溯，减少计算。

class Solution {
public:
    bool hash[10]={false};
    int p[10]={0};
    void solve(vector<vector<string>> &result,int &n, int index){
        //边界判断
        if(index==n+1){
            //此时p[]为n列皇后所在的行号
            vector<string> res;
            for(int j=1;j<index;j++){
                string s;
                for(int i=1;i<index;i++){
                    if(i!=p[j]){
                        s.append(".");
                    }else{
                        s.append("Q");
                    }
                }
                res.push_back(s);
            }
            
            result.push_back(res);
            return;
        }
		//第index列，列是根据递归依次增长的，行是用hash表标记的，对角线再次判断
        for(int i=1;i<=n;i++){
            //第i行还没有皇后
            if(hash[i]==false){
                bool flag = true;
				//此处的循环意思是，如果i放在p[index]不合法，那就不放
                for(int pre=1;pre<index;pre++){
                    //第index列皇后的行号为i，第pre列皇后的行号为p[pre]
                    if(abs(index-pre)==abs(i-p[pre])){
                        flag=false;//与之前的皇后在同一对角线
                        break;
                    }
                }
                if(flag){
                    p[index]=i;
                    hash[i]=true;
                    solve(result,n,index+1);
                    hash[i]=false;
                }
            }
            
        }
    }
    vector<vector<string>> solveNQueens(int n) {
        vector<vector<string>> result;
        solve(result,n,1);
        return result;
    }
};