回溯法

回溯法递归通用写法：
1.递归函数参数：
（1）原数组（可以用引用也可以值传递，不修改它的值）
（2）本次递归的开始位置，表示当前递归的子序列（值传递）
（3）用于保存一条路径中当前已搜到的路径的vector，即用根节点到当前节点的元素集合（一般为值传递，不是引用传递，因为需要自动维护栈，不用人工返回上一层节点）（引用传递）
（4）用于保存满足条件的所有路径，一般为vector<vector>>形式的引用，当搜索到叶节点时，如果路径满足要求则将其加入其中。（引用传递）

递归函数写法：

vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> res; //满足条件的结果，即（4）
        vector<int> temp; //保存当前搜索的路径，即（3）

        dfs(res, nums, temp, 0); //递归函数

        return res;
    }
 void dfs(vector<vector<int>> &res, vector<int> &nums, vector<int> temp, int i) {//将nums中i位以后的序列求子集，用tmp保存一条路径的结果，当走到叶节点时，将结果保存到res中
        if (i == nums.size()) { //终止条件，搜索到叶节点返回
            res.push_back(temp); //如果当前路径满足条件则加入总结果中
            return ;
        }
	    //不同分支递归搜索，有几个分支就有几个对应的递归函数？
	    dfs(res,nums,tmp,i+1);
    }

leetcode784, 78可以验证该通式

1.leetcode784.字母大小写全排列
参考：
https://leetcode.com/problems/letter-case-permutation/discuss/130680/C%2B%2B-6ms-beat-100
递归：

vector<string> letterCasePermutation(string S) {
        vector<string> vs;
        helper(vs,S,0);
        return vs;
    }    
    void helper(vector<string>& vs,string& S,int p){ //对vs从p以后的序列进行处理（由于该递归函数传递的是S的引用，因此不用再传当前路径变量）
        if(p == S.size()) { //到末尾了，一条路径搜索完毕，保存结果
            vs.push_back(S);
            return ;
        }
        if(S[p] >= '0' && S[p] <= '9') helper(vs,S,p+1);//如果是数字，则跳过
        else if(S[p] >= 'a' && S[p] <= 'z'){//是小写字母
            helper(vs,S,p+1); //该位置为小写字母，下来处理后面的
            S[p] += 'A'-'a';
            helper(vs,S,p+1);  //将该位置变为大写字母，下来处理后面的
        }
        else if(S[p] >= 'A' && S[p] <= 'Z'){ //是大写字母，与上面类似
            helper(vs,S,p+1);
            S[p] += 'a'-'A';
            helper(vs,S,p+1);
        }
    }

递归写法中，如果到路径头了，则返回。否则处理当前节点的所有可能取值，然后递归求下一层节点的取值。即在层与层之间是通过递归来完成的。

非递归：
https://leetcode.com/problems/letter-case-permutation/discuss/151015/C%2B%2B-Iterative-Solution-4ms-beat-100

class Solution {
public:
    char switchCase(const char& c) {
        if(c >= 'A' && c <= 'Z')
            return tolower(c);
        else
            return toupper(c);
    }
    
    vector<string> letterCasePermutation(string S) {
        vector<string> strings;
        strings.push_back(S);
        for(int i = 0; i < S.length(); i++) {//对于字符串的每个字符
            if(isalpha(S[i])) { //如果是字母
                int stop = strings.size();
                for(int j = 0; j < stop; j++) {//对于已保存的没个结果
                    string s = strings[j];
                    s[i] = switchCase(s[i]);//变换该字符的大小写
                    strings.push_back(s);//保存
                }
            }
        }
        return strings;
    }
};

比如对于ab,先取第一个字符，可能结果为a,A保存起来。在对于第二个字符，可能结果为b,B。分别加到已有结果后面，得到ab,aB,Ab,AB.

2.leetcode39.组合总和
自己博客有

3.leetcode40.组合总和II
和39的区别是这个题里数组的元素不允许重复选取，因此每次递归是从下一个元素开始的，而39的下一次递归还是从当前元素开始的。

4.leetcode46.全排列
参考：
https://leetcode.com/problems/permutations/discuss/18247/My-elegant-recursive-C%2B%2B-solution-with-inline-explanation
1,2,3,4的全排列记做P(1,2,3,4).则P(1,2,3,4)=1+P(2,3,4) and 2+P(1,3,4) and 3+P(1,2,4) and 4+P(1,2,3).做的时候需要先将序列的每个元素先和第一个元素交换，然后求除去第一个元素外的全排列，最后将元素交换回来
（代码中的引用其实没看懂）

class Solution {
public:
    vector<vector<int> > permute(vector<int> &num) {
	    vector<vector<int> > result;
	    
	    permuteRecursive(num, 0, result);
	    return result;
    }
    
    // permute num[begin..end]
    // invariant: num[0..begin-1] have been fixed/permuted
	void permuteRecursive(vector<int> &num, int begin, vector<vector<int> > &result)	{
		if (begin >= num.size()) {
		    // one permutation instance
		    result.push_back(num);
		    return;
		}
		
		for (int i = begin; i < num.size(); i++) {
		    swap(num[begin], num[i]);
		    permuteRecursive(num, begin + 1, result);
		    // reset
		    swap(num[begin], num[i]); //经过递归后还能保证之前交换元素的下标不变吗？传的是引用啊。。
		}
    }
};

5.leetcode47.全排列II（略看的，没看太明白）
参考：
https://leetcode.com/problems/permutations-ii/discuss/18632/Short-40ms-C%2B%2B-solution-similar-to-Permutation-I-solution
和46的区别是，47新增了一个unordered_set，在每次循环中进行交换元素之前，如果要交换的元素已经出现过就跳过该循环

6.leetcode78. 子集（自己博客有，在面试100题里面）
https://blog.youkuaiyun.com/camellhf/article/details/73551410

7.leetcode79.单词搜索（自己博客有）