回溯法详解

解决一个回溯问题，实际上就是一个决策树的遍历过程。需要思考 3 个问题：
1、路径：也就是已经做出的选择。
2、选择列表：也就是你当前可以做的选择。
3、结束条件：也就是到达决策树底层，无法再做选择的条件。
回溯法代码框架：

result = []
def trackback(路径， 选择列表)：
	if 满足结束条件：
		result.add(路径)
		return
	for 选择 in 选择列表：
		//做选择
		路径.add(选择)
		//进入下一层决策
		trackback(路径，选择列表)
		//撤销选择
		路径.remove(选择)

一.全排列问题
n个不重复的数，全排列有n! 个
第一个位置有n个选择，第二个位置有n-1个选择。。。最后一个位置1个选择，所以不重复的n个数一共有n! 个
所以我们先固定第一个位置，然后固定第二个位置，依次进行到固定最后一个位。
leetcode 46 全排列 I :
https://leetcode-cn.com/problems/permutations/

class Solution {
public:
	vector<vector<int>> result;
    vector<vector<int>> permute(vector<int>& nums) {
        //回溯法
        vector<vector<int>> result;
        if(nums.size() == 0) return result;
        trackback(0, nums);
        return result;
    }
    //
    void trackback(int x, vector<int> &nums)
    {
        //满足终止条件，将结果temp加进result中，即将路径加入结果中
        if(x == nums.size())
        {
            result.push_back(nums);
            return;
        }
        //选择列表中做选择，递归，撤销选择
        for(int i = x; i < nums.size(); ++i)
        {
            //做选择
            swap(nums[x], nums[i]);
            //递归下一步
            trackback(x+1, nums);
            //撤销选择
            swap(nums[x], nums[i]);
        }
    }
    void swap(int &a, int &b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
};

leetcode 47 全排列 II
https://leetcode-cn.com/problems/permutations-ii/
有重复的n的数字，故要剔除重复元素的情况

class Solution {
public:
	vector<vector<int>> result
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        //回溯法
        vector<vector<int>> result;
        if(nums.size() == 0) return result;
        trackback(0, nums);
        return result;
    }
    void trackback(int x, vector<int> &nums)
    {
        //满足终止条件，将路径加入结果中
        if(x == nums.size())
        {
            result.push_back(nums);
            return;
        }
        //新建一个hash，维护元素不重复
        unordered_set<int> hash;
        //在选择列表中做出选择
        for(int i = x; i < nums.size(); i++)
        {
            //如果重复则跳出
            if(hash.find(nums[i]) != hash.end()) continue;
            //如果不重复，加入hash，再做出选择
            hash.insert(nums[i]);
            swap(nums[x], nums[i]);
            //递归下一步
            trackback(x+1, nums);
            //撤销选择
            swap(nums[x], nums[i]);
        }
    }
    void swap(int &a, int &b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
};

二.N皇后问题
n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击

给定一个整数 n，返回所有不同的 n 皇后问题的解决方案。每一种解法包含一个明确的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
我们逐行的进行操作，每一行可以在任意一个位置放置皇后，如果该位置放置皇后后不满足N皇后条件则剔除，满足条件则相当于做出选择。

class Solution {
public:
	vector<vector<string>> result；
    vector<vector<string>> solveNQueens(int n) {
        //回溯法
        vector<vector<string>> result;
        //初始化N X N个. 作为棋盘
        vector<string> path(n, string(n, '.'));
        if(n == 0) return result;
        trackback(0, path);
        return result;
    }
    //决策树的每一层表示棋盘上的每一行；每个节点可以做出的选择是，在该行的任意一列放置一个皇后。
    void trackback(int row, vector<string> &path)
    {
        //满足结束条件即当前行超过边界，将path加入result
        if(row == path.size())
        {
            result.push_back(path);
            return;
        }
        int n = path[row].size();
        for(int col = 0; col < n; ++col)
        {
            //剪枝
            if (!isvalid(path, row, col)) continue;
            //做选择
            path[row][col] = 'Q';
            //递归下一步
            trackback(row+1, path);
            //撤销选择
            path[row][col] = '.';
        }
    }
    bool isvalid(vector<string> &path, int row, int col)
    {
        //检查同列是否有皇后
        for(int i = row; i >= 0; --i) if(path[i][col] == 'Q') return false;
        //检查左上方是否有皇后冲突
        for(int i = row-1, j = col-1; i >= 0 && j >= 0; --i, --j)
        {
            if(path[i][j] == 'Q') return false;
        }
        //检查右上方是否有皇后冲突
        for(int i = row-1, j = col+1; i >= 0 && j < path.size(); --i, ++j)
        {
            if(path[i][j] == 'Q') return false;
        }
        return true;
    }
};

三.解数独
leetcode 37 解数独
https://leetcode-cn.com/problems/sudoku-solver/

class Solution {
public:
    void solveSudoku(vector<vector<char>>& board) {
        //回溯法
        trackback(0, 0, board);
        return;
    }
    //逐行的，从左到右，在每一个位置上试探1-9，成功就进入下一个位置，失败就撤销本次选择做下一个选择
    bool trackback(int row, int col, vector<vector<char>> &board)
    {
        //9
        int n = board.size();
        //说明当前行已经全部试探过，换到下一行的第一个位置
        if(col == n) return trackback(row+1, 0, board);
        //满足终止条件,已经超过了行数。最后一行最后一个位置[8,8]试探完后会试探[8,9],会执行[9,0]
        if(row == n) return true;
        //这个位置的数字已经给出来了，不需要试探，直接试探下一个位置
        if(board[row][col] != '.') return trackback(row, col+1, board);
        //如果这个位置需要我们插入数字，遍历可选数字
        for(char i = '1'; i <= '9'; ++i)
        {
            //判断该数字是否满足当前数独有效，剪枝
            if(!isvalid(row, col, i, board)) continue;
            //做选择
            board[row][col] = i;
            //进行下一步试探，如果能成功就一直往下
            if(trackback(row, col+1, board)) return true;
            //撤销选择
            board[row][col] = '.';
        }
        //到这里说明1-9都试过了，不行，上一次选择失败，需要回溯
        return false;
    }
    //判断当前填入的数字是否满足 有效数独
    bool isvalid(int row, int col, char ch, vector<vector<char>> &board)
    {
        for(int i = 0; i < 9; ++i)
        {
            //判断该行
            if(board[row][i] == ch) return false;
            //判断该列
            if(board[i][col] == ch) return false;
            //判断子数独
            if(board[row/3*3 + i/3][col/3*3 + i%3] == ch) return false;
        }
        return true;
    }
};