回溯算法解题套路框架 LeetCode 46 全排列1 ； LeetCode 47 全排列 2 ；LeetCode 51 N皇后 ；

搬运 博主 lambdadong 的博客：   labuladong 的算法小抄

回溯算法的框架：

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
    result.add(路径)
    return

    # 做选择
    将 选择i 从选择列表中移除/标记 选择i 已经选择过
    路径.add(选择i)
    backtrack(路径, 选择列表)
    # 撤销选择
    路径.remove(选择1)
    将该选择i再加回选择列表

一、全排列问题

       1.1  LeetCode 46 全排列1   求没有重复元素的数组的全排列

直接套用框架：

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        //sort(nums.begin(),nums.end());
        int len=nums.size();
        vector<bool> visited(len,false);
        backtrack(nums,visited,0);
        return res;
    }
// 路径：记录在 path 中
// 选择列表：visited[i] 为true 的nums[i]
// 结束条件：depth == nums.size() 走到"决策树"的叶节点
    void backtrack(vector<int>& nums,vector<bool>& visited ,int depth) {
        int len=nums.size();
        if ( depth == nums.size()) {
            res.push_back(path);      
            return;
        }
        for (int i=0;i<len;i++) {
            if (visited[i]) continue;
            //if (i>0 && nums[i]==nums[i-1] && visited[i-1])  continue;
            visited[i] = true;
            path.push_back(nums[i]);
            backtrack(nums,visited,depth+1);
            path.pop_back();
            visited[i] = false;
        }
    }
};

 

1.2   LeetCode 47 全排列2   求有重复元素的数组的全排列

       在平时项目中遇到这种需求，可以直接使用 c++ STL 的   next_permutation 函数生成所有的排列，

得到的结果就已经是去重过的了，且有很好的效率。 注意使用  next_permutation  前 ，需要 先将数组

排序 。代码如下:  

#include<algrithm>
#include<vector>
using namespace std;

  vector<vector<int>> permuteUnique(vector<int>& nums)
    {
        sort(nums.begin(), nums.end());
        vector<vector<int>>result;
        result.push_back(nums);
        while (next_permutation(nums.begin(), nums.end()))
        {
            result.push_back(nums);
        }
        return result;
    }

     对比 1.1 没有重复的元素，使用1.1 中的代码得到的全排列中会包含重复的排列，可以在得到所有的排列之后，

使用set<vector<int>> 辅助 去重就可。

void remove_repeated_vec(vector<vector<int>> &res)
    {
        set<vector<int>> unique_set;
        vector<vector<int>>::iterator ite;
        vector<vector<int>> tmp_res;
        for(ite = res.begin();ite != res.end();++ite)
        {
            if(unique_set.find(*ite) == unique_set.end())
            {
                unique_set.insert(*ite);
                tmp_res.push_back(*ite);
            }
        }
        res = tmp_res;
        return;
   }

或者直接把  1.1 中 line 7 和 line 24 两处的注释取消，

 

二.   N皇后

class Solution {
public:
   vector<vector<string>> res;

    /* 输入棋盘边长 n，返回所有合法的放置 */
    vector<vector<string>> solveNQueens(int n)
    {
        // '.' 表示空，'Q' 表示皇后，初始化空棋盘。
        vector<string> board(n, string(n, '.'));
        backtrack(board, 0);
        return res;
    }

    // 路径：board 中小于 row 的那些行都已经成功放置了皇后
    // 选择列表：第 row 行的所有列都是放置皇后的选择
    // 结束条件：row 超过 board 的最后一行
    void backtrack(vector<string>& board, int row)
    {
        // 触发结束条件
        if (row == board.size()) {
            res.push_back(board);
            return;
        }

        int n = board[row].size();
        for (int col = 0; col < n; col++) {
            // 排除不合法选择
            if (!isValid(board, row, col)) 
                continue;
            // 做选择
            board[row][col] = 'Q';
            // 进入下一行决策
            backtrack(board, row + 1);
            // 撤销选择
            board[row][col] = '.';
        }
    }

    /* 是否可以在 board[row][col] 放置皇后？ */
    bool isValid(vector<string>& board, int row, int col)
    {
        int n = board.size();
        // 检查列是否有皇后互相冲突
        for (int i = 0; i < n; i++) {
            if (board[i][col] == 'Q')
                return false;
        }
        // 检查右上方是否有皇后互相冲突
        for (int i = row - 1, j = col + 1; 
                i >= 0 && j < n; i--, j++) {
            if (board[i][j] == 'Q')
                return false;
        }
        // 检查左上方是否有皇后互相冲突
        for (int i = row - 1, j = col - 1;
                i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] == 'Q')
                return false;
        }
        return true;
    }
};