回溯算法

回溯的步骤：
①画出递归树，找到状态变量(回溯函数的参数)，这一步非常重要※
②根据题意，确立结束条件
③找准选择列表(与函数参数相关),与第一步紧密关联※
④判断是否需要剪枝
⑤作出选择，递归调用，进入下一层
⑥撤销选择

类型：
1.子集，组合： 子集，子集II，组合，组合总和
2.全排列：全排列，全排列II，字符串的全排列，字母大小写全排列
3.搜索：解数独，单词搜索，N皇后，分割回文串

A、子集：
leetcode71.
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
示例:
输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]
(1)画出递归树，选择列表里的数，都是选择路径后面的数，这时候应该使用一个参数start，来标识当前的选择列表的起始位置，也就是标识每一层的状态。
void backtrack(vectornums,vector&path,int start)
(2)找结束条件，此题非常特殊，所有路径都应该加入结果集，所以不存在结束条件。或者说当start参数越过数组边界的时候，程序就自己跳过下一层递归了，因此不需要手写结束条件,直接加入结果集
res.push_back(path);
(3)找选择列表：子集问题的选择列表，是上一条选择路径之后的数,即
for(int i=start;i<nums.size();i++)
(4)是否需要剪枝：从递归树看，路径是否有重复的，没有重复也没有不符合条件的，不需要剪枝。
(5)做出选择(for循环里面的)

void backtrack(vector<int>nums,vector<int>&path,int start)
{
    for(int i=start;i<nums.size();i++)
    {
        path.push_back(nums[i]);//做出选择
        backtrack(nums,path,i+1);//递归进入下一层，注意i+1，标识下一个选择列表的开始位置，最重要的一步
    }
}

(6)撤销选择
path.pop_back();

class Solution {
    vector<vector<int>> res;
    void dfs(vector<int>& nums, vector<int>& path, int start) {
        res.push_back(path);
        for (int i = start; i < nums.size(); i++) {
            path.push_back(nums[i]);
            dfs(nums, path, i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        res.clear();
        if(nums.size()==0) {
            return res;
        }
        vector<int> path;
        dfs(nums, path, 0);
        return res;
    }
};

B、子集II(存在重复元素)
(4)是否需要剪枝？ 需要先对数组排序：
if (i > start && nums[i] == nums[i-1]) {//剪枝去重
	continue;
}

class Solution {
    vector<vector<int>> res;
    void dfs(vector<int>& nums, vector<int>& path, int start) {
        res.push_back(path);
        for (int i = start; i < nums.size(); i++) {
            if (i > start && nums[i] == nums[i-1]) {
                continue;
            }
            path.push_back(nums[i]);
            dfs(nums, path, i+1);
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        res.clear();
        if (nums.size() == 0) {
            return res;
        } 
        sort(nums.begin(), nums.end());   
        vector<int> path;
        dfs(nums, path, 0);
        return res;
    }
};

C、组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
示例：输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
[7],
[2,2,3]
]
(1)画递归树：
1,2和2,1是同一个组合，所以需要引入start标识选择列表的起始位置。每个状态还需要一个sum变量，来记录当前路径的和。
void backtrack(vector& nums,vector&path,int start,int sum,int target)

(2)结束条件：路径总和等于target时
if(target==sum)
{
res.push_back(path);
return;
}
(3)选择列表： for(int i=start;i<nums.size();i++)
(4)是否需要剪枝：从①中的递归树中发现，当前状态的sum大于target的时候就应该剪枝，不用再递归下去了
for(int i=start;i<nums.size();i++) {
if(sum > target)
continue;
}
(5)做出选择：每个数可以被无限次选择，所以i不用+1

总结：子集、组合类问题，关键是用一个start参数来控制选择列表！！

排列：
A、全排列：
给定一个 没有重复 数字的序列，返回其所有可能的全排列。
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
(1)画递归树：如果我们固定了(选择了)某个数，那么他的下一层的选择列表就是——除去这个数以外的其他数！！需要引入一个used数组来记录使用过的数字：
void backtrack(vector& nums,vector&used,vector& path)//你也可以把used设置为全局变量
(2)找结束条件：if(path.size()==nums.size())
(3)找准选择列表：
for(int i=0;i<nums.size();i++)
{
if(!used[i])//从给定的数中除去用过的，就是当前的选择列表
{
}
}
(4)判断是否需要剪枝:!used[i]已经是剪枝
(5)做出选择：
(6)撤销选择：

可以发现“排列”类型问题和“子集、组合”问题不同在于：“排列”问题使用used数组来标识选择列表，而“子集、组合”问题则使用start参数。

class Solution {
    vector<vector<int>> res;
    vector<bool> used;
    void dfs(vector<int>& nums, vector<int>& path) {
        //结束条件
        if (path.size() == nums.size()) {
            res.push_back(path);
            return;
        }

        for(int i = 0; i < nums.size(); i++) {
            if (used[i]) {
                continue;
            }
            used[i] = true;
            path.push_back(nums[i]);
            dfs(nums, path);
            path.pop_back();
            used[i] = false;
        }
        return;
    }
public:
    vector<vector<int>> permute(vector<int>& nums) {
        res.clear();
        if(nums.size() == 0) {
            return res;
        }
        used = vector<bool>(nums.size(), false);
        vector<int> path;
        dfs(nums, path);
        return res;
    }
};

B、全排列II
给定一个可包含重复数字的序列，返回所有不重复的全排列。
输入: [1,2,2]
输出:
[
[1,2,2],
[2,1,2],
[2,2,1]
]
当遇到有重复元素求子集时，先对nums数组的元素排序，再用if(i>start&&nums[i]==nums[i-1])来判断是否剪枝，那么在排列问题中又该怎么做呢？

void backtrack(vector<int>& nums,vector<bool>&used,vector<int>& path)//used初始化全为false
{
    if(path.size()==nums.size())
    {
        res.push_back(path);
        return;
    }
    for(int i=0;i<nums.size();i++)//从给定的数中除去，用过的数，就是当前的选择列表
    {
        if(!used[i])
        {
            if(i>0&&nums[i]==nums[i-1]&&!used[i-1])//剪枝，三个条件
                continue;
            path.push_back(nums[i]);//做选择
            used[i]=true;//设置当前数已用
            backtrack(nums,used,path);//进入下一层
            used[i]=false;//撤销选择
            path.pop_back();//撤销选择
        }
    }
}

搜索：
leetcode79.单词搜索：
给定一个二维网格和一个单词，找出该单词是否存在于网格中。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

class Solution {
    vector<vector<bool>> vis;
    int m, n;
    int dir[4][2] = {{1,0},{-1,0},{0,1},{0,-1}};
    bool isInArea(int x, int y) {
        if (x < 0 || x >= m || y < 0 || y >= n) {
            return false;
        } else {
            return true;
        }
    }
    bool dfs(vector<vector<char>>& board, string word, int index, int x, int y) {
        if (index == word.size() - 1) {
            if (word[index] == board[x][y]) {
                return true;
            }
        }

        if (word[index] != board[x][y]) {
            return false;
        }
        vis[x][y] = true;
        for (int i = 0; i < 4; i++) {
            int nx = x + dir[i][0];
            int ny = y + dir[i][1];
            if (isInArea(nx, ny) && !vis[nx][ny] ) {
                if (dfs(board, word, index+1, nx, ny)) {
                    return true;
                }
            }
        }
        vis[x][y] = false;
        return false;
    }
public:
    bool exist(vector<vector<char>>& board, string word) {
        m = board.size();
        if (!m) {
            return false;
        }
        n = board[0].size();
        vis = vector<vector<bool>>(m, vector<bool>(n, false));

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (dfs(board, word, 0, i, j)) {
                    return true;
                }
            }
        }
        return false;
    }
};