LeetCode51:N-Queens

最新推荐文章于 2021-12-20 19:41:06 发布

原创最新推荐文章于 2021-12-20 19:41:06 发布 · 1.1k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

LeetCode 同时被 2 个专栏收录

95 篇文章

订阅专栏

LeetCode

94 篇文章

订阅专栏

本文介绍了一种解决N皇后问题的方法，通过计算n个皇后在n×n棋盘上的所有不冲突布局。采用递归全排列算法并结合冲突判断条件，实现了有效的解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.
![这里写图片描述](https://img-blog.youkuaiyun.com/20150609105847270)
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.."]
]
Show Tags

这道题是8皇后问题的推广，它推广到了n个皇后问题。但是解题思路还是一样的。
基本思路：

很明显n个皇后最开始的初始值应该是不同的，给n个皇后赋一个和它们下标相同的初值，这些初值构成一个数组。
求解这个数组的全排列，这是经典的无重复数字的数组的全排列问题。
根据皇后问题关系求出全排列中符合要求的排列。
对于每一个排列对应皇后的一种摆放位置，将它们按照指定格式输出。

排列的分析见这篇博客。

runtime:92ms

class Solution {
public:
    vector<vector<string> > solveNQueens(int n) {
        vector<vector<string> > result;
        vector<int> nums;
        for(int i=0;i<n;i++)
            nums.push_back(i);
        vector<vector<int> > base=permutation(nums);
        auto iter1=base.begin();
        for(;iter1!=base.end();iter1++)
        {
            vector<string> vecString;
            vector<int> vec=*iter1;
            for(int i=0;i<n;i++)
            {
                string str(n,'.');
                str[vec[i]]='Q';
                vecString.push_back(str);
            }
            result.push_back(vecString);
        }
        return result;

    }

    vector<vector<int> > permutation(vector<int> &nums)
    {
        vector<vector<int> >result;
        permutationChild(nums,0,result);
        return result;
    }

    void permutationChild(vector<int> &nums,int offset,vector<vector<int> >&result)
    {

        if(offset==nums.size()-1)
        {
            if(judge(nums))
                result.push_back(nums);
            return;
        }

        auto base=nums.begin()+offset;
        auto iter=base;
        for(;iter!=nums.end();iter++)
        {
            swap(*base,*iter);
            permutationChild(nums,offset+1,result);
            swap(*base,*iter);
        }
    }

    bool judge(vector<int> & nums)
    {
        int length=nums.size();
        for(int i=0;i<length;i++)
        {
            for(int j=i+1;j<length;j++)
            {
                if(abs(i-j)==abs(nums[i]-nums[j]))
                    return false;
            }
        }

        return true;
    }
};