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

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

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

---

前言

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

实质：决策树的遍历

三要素

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

回溯递归框架

result = []
def backtrack(路径, 选择列表):
	if 满⾜结束条件:
		result.add(路径)
		return
	for 选择 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}进行全排列：

1. 保持2不变，对3、4全排列；
2. 保持3不变，对4进行全排列；
3. 得出2， 3， 4；
4. 交换3、4；
5. 保持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皇后问题

大体意思：

思路

1. 套用框架，明确三要素路径、选择列表和结束条件；
2. 当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 choice
		backtrack(...)
		undo choice

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

2020/08/06 00:45
@luxurylu