回溯算法（全排列、组合、N皇后问题）

回溯算法（全排列、N皇后问题）

暴力穷举，这是不可避免，因为回溯法没有重复子结构，所以其时间复杂度大于等于O(N!)；

前言

本文章内容部分参考公众号labuladong关于回溯算法的讲解，仅为笔者日后复习，或读者参考学习，无商业用途。

实质：决策树的遍历

三要素

路径：当前已经做出的决策；
选择列表：当前可以做出的决策；
结束条件：到达决策树底层，一般就是选择列表为空；

回溯递归框架

result = []
def backtrack(路径, 选择列表):if 满⾜结束条件:result.add(路径)returnfor 选择 in 选择列表:做选择backtrack(路径, 选择列表)撤销选择

核心：for循环中的递归，递归前做出决策，递归后撤销决策

经典例题

全排列

问题：n个非重复数字的全排列？

代码实现

回溯框架

/*
full permutation
track: track path
nums: selection list
*/
void permute(vector<int> track, vector<int> &nums){/* end condition */if(track.size() == nums.size()){result.push_back(track);/* result is the global vector */       }/* backtrack *//* layer one have nums.size() paths */for(auto n :nums){/* make sure the chioce valid */if(find(track, n)){continue;}/* make choice */track.push_back(n);/* to down recursion */permute(track, nums);/* undo choice */track.pop_back();}
}

判断元素是否在选择列表中；
这样判断时间复杂度是O(n)，当然我们可以通过set的方式记录，用空间换时间，实际上，我们还可以使用交换的方式；

/*
make sure the chioce valid
*/
bool find(vector<int> track, int n){for(auto t : track){if(t == n){return true;}}return false;
}

打印

/*
vector二维数组打印
*/
void printVec(vector<vector<int>> &obj){for(auto item : obj){for(auto it : item){cout << " " << it;}cout << endl;}
}

主函数

vector<vector<int>> result;
int main(){vector<int> nums;nums.assign({2, 3, 5, 4});permute(vector<int>(), nums);printVec(result);getchar();return 0;
}

全排列经典算法（交换写法）

思路
对{2, 3, 4}进行全排列：

保持2不变，对3、4全排列；
保持3不变，对4进行全排列；
得出2， 3， 4；
交换3、4；
保持4不变，对3进行全排列；

总结就是：
每个数依次打头，求剩下的n-1个数的全排列，而n-1个数的全排列由n-2个数推出…直到一个数的全排列，开始回溯；

/*
nums：个位数的数组(假设从 1-9)，eg：{2, 3, 4}；
obj: 记录全排列结果；
pinNum：pinNum+1表示当前固定的数字个数，从1开始；
len：总个位数，res的长度；
*/
void permutation(vector<int> &nums, vector<vector<int>> &res, int pinNum, int len){/* 判断是否到达最后一个数 */if(pinNum+1 == len){/* 将当前排列记录到obj */res.push_back(nums);return;}/* pinNum's full permutation */for(int i=pinNum; i<len; i++){swap(nums[i], nums[pinNum]);permutation(res, obj, pinNum+1, len);swap(nums[i], nums[pinNum]);}
}

组合

代码实现：

class Solution {vector<vector<int>> res;
public:void combine(vector<int> track, int pinNum, int n, int k){/* end condition */if(track.size() == k){res.push_back(track);return ;}/* begin num */for(int i = pinNum; i <= n; i++){track.push_back(i);combine(track, i+1, n, k);/* i+1而不是pinNum+1，因为自身不能选两次 */track.pop_back();}}vector<vector<int>> combine(int n, int k) {combine(vector<int>(), 1, n, k);return res;}
};

N皇后问题

大体意思：

思路

套用框架，明确三要素路径、选择列表和结束条件；
当Queen成功摆放完第N行结束递归；

代码实现

声明全局数组为结果集

vector<vector<string>> res;

主调函数：

vector<vector<string>> solveNQueen(int n){/* 初始化路径track为'.',可选列表从track[0]开始 */backtrack(vector<string>(n, '.'), 0);return res;
}

套用框架：
路径：当前摆放Queen行之前成功摆放Queen的位置；
选择列表：当前行的所有位置都是选项，不过需要判断是否合法；
结束条件：Queen已经成功摆放完第N行；

void backtrack(vector<string> &track, int row){int n = track.size();/* end condition */if(row == n){res.push_back(track);return;}for(int col = 0; col < n; col++){/* 检查当前位置是否合法 */if(!isValid(track, row, col){continue;}/* make choice */track[row][col] = 'Q';/* recursion */backtrack(track, row+1);/* undo choice */track[row][col] = '.';}
}

检查暴力当前位置是否合法

bool isValid(vector<string> track, int x, int y) {/* 当前列 */for (int i = 0; i < x; i++) {if (track[i][y] == 'Q') {return false;}}/* 左上 */for (int i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {if (track[i][j] == 'Q') {return false;}}/* 右上 */for (int i = x - 1, j = y + 1; i >= 0 && j < track[i].size(); i--, j++) {if (track[i][j] == 'Q') {return false;}}return true;
}

哈希表检查是否合法,需要声明一个全局哈希表memo，并在每次做出选择时memo[row] = col，每次撤销选择，删除该键值对；

bool isValid(int row, int col) {for (auto p : memo) {if (p.second == col || abs(p.first - row) == abs(p.second - col)) {return false;}}return true;
}

总结

回溯算法的实质还是多叉树的遍历问题，深度优先遍历，清楚遍历的操作，框架如下：

def backtrack(...)for 选择 in 选择列表make choicebacktrack(...)undo choice

注意
维护好走过的 [路径] 和当前可选的 [选择列表]，并写出合适判断选择合法性的函数，最后碰到终止条件，将本次遍历结果存入结果集；

2020/08/06 00:45
@luxurylu