LeetCode39/40/22/77/17/401/78/51/46/47/79 11道回溯题（Backtracking）

LeetCode 39

 1 class Solution {
 2 public:
 3     void dfs(int dep, int maxDep, vector<int>& cand, int target)
 4 {
 5     if (target < 0)return;
 6     if (dep == maxDep)
 7     {
 8         if (target == 0)//到达尾部且等于target
 9         {
10               vector<int> temp;
11               for (int i = 0; i < maxDep; i++)
12               {
13                 for (int j = 0; j < num[i]; j++)
14                     temp.push_back(cand[i]);
15               }
16                 ret.push_back(temp);
17             }
18             return;
19         }
20         for (int i = 0; i <= target / cand[dep]; i++)//枚举合适的情况
21         {
22             num[dep] = i;
23             dfs(dep + 1, maxDep, cand, target - i*cand[dep]);
24         }
25 }
26 vector<vector<int>> combinationSum(vector<int>& candidates, int target) 
27 {
28     int n = candidates.size();
29     if (n == 0)return ret;
30     sort(candidates.begin(), candidates.end());
31     num.resize(n);
32     ret.clear();
33     dfs(0, n, candidates, target);
34     return ret;
35 
36 }
37 private:
38     vector<vector<int>> ret;//返回的结果
39     vector<int> num;//用来存储每个数字的次数
40 };

  LeetCode 40

class Solution {
public:
void dfs(int dep, int maxDep, vector<int>& cand, int target)
{
    if (target < 0)return;
    if (dep == maxDep)
    {
        if (target == 0)
        {
              vector<int> temp;
              for (int i = 0; i < maxDep; i++)
              {
                for (int j = 0; j < num[i]; j++)
                    temp.push_back(cand[i]);
              }
                res.insert(temp);
            }
            return;
        }
        for (int i = 0; i<=1; i++)
        {
            num[dep] = i;
            dfs(dep + 1, maxDep, cand, target - i*cand[dep]);
        }
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) 
{
    int n = candidates.size();
    if (n == 0)return ret;
    sort(candidates.begin(), candidates.end());
    num.resize(n);
    ret.clear();
    dfs(0, n, candidates, target);
    set<vector<int>>::iterator it= res.begin();
    for (;it!=res.end();it++)
    {
        ret.push_back(*it);
    }
    return ret;

}

private:
    vector<vector<int>> ret;
    set<vector<int>> res;
    vector<int> num;
};

 LeetCode 22

backtracking函数书写的一般规则：

(1)函数参数一般要包括位置或者其它(如本题中的还可以剩余左括号个数及左边有多少个左括号没有关闭),这些都是为函数内容作为判断条件，要选择好。

(2)函数开头是函数终止条件(如本题中已经没有左括号可以使用了，故return）,并将结束得到的一个结果（元素可以不取的话，则将临时结果变量作为函数的参数<如subset>，每个元素都要取一个结果，则作为类成员）放入result中

 (3)就是函数的后半部分，为递归，函数该位置可以放那些元素(循环)，每种元素放入后递归下一个位置的元素，当然包括参数的变化。

(1)参数：pos:迭代位置，共有2*n个元素，表示迭代到第几个位置了, left表示左边已经有多少个左括号没有关闭，当left==0时就不能迭代右括号了，remain表示还可以加入左括号的个数，当remain==0的时候，就不能迭代左括号了。

(2)终止条件：当remain==0时，只能加入右括号了，并将这一结果加入最后的结果中

(3)每个位置都只能放入左右括号两种情况，分别取这两种情况，然后进行下一次迭代。

class Solution {
public:
    void dfs(int pos, string &str, int left, int remain, int n){   // left表示左边有多少个左括号没有关闭
        if(remain == 0){  // 左括号使用完毕  故全部为右括号
            for(int i = pos; i < 2*n; i++)
                str[i] = ')';
            result.push_back(str);
            return;
        }
        
        if(remain > 0){             // remain!=0 说明还可以使用左括号
            str[pos] = '(';
            dfs(pos+1, str, left+1, remain-1, n);
        }
        if(left != 0){               // left！=0 表示左边还有左括号没有关闭，故可以使用)
            str[pos] = ')';
            dfs(pos+1, str, left-1, remain, n);
        }
    }
    vector<string> generateParenthesis(int n) {
        string str;
        str.resize(2*n);
        dfs(0, str, 0, n, n);
        return result;
        
    }
private:
    vector<string> result;
};

 Leetcode 77

class Solution {
private:
    vector<vector<int>> result;
    vector<int> tmp;
public:
    void dfs(int dep, const int &n, int k, int count)
    {
        if (count == k)
        {
            result.push_back(tmp);
            return;
        }
        if (dep < n - k + count)
        {
            dfs(dep + 1, n, k, count);//不取当前数
        }
        tmp[count] = dep + 1;         //取当前数
        dfs(dep + 1, n, k, count+1);
        
    }
    vector<vector<int>> combine(int n, int k)
    {
        if (k>n)k = n;
        tmp.resize(k);
        dfs(0, n, k, 0);
        return result;
    }

};

 LeetCode 17

string NumToStr[10] = {"", "","abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}; 
class Solution {
private:
    string str;
    vector<string> result;
public:
    int charToInt(char c)
    {
        int i;
        stringstream ss;
        ss << c;
        ss >> i;
        return i;
    }
    void dfs(int dep, int maxDep, const string &digits)
    {
        if (dep == maxDep)
        {
            result.push_back(str);
        }
        int index = charToInt(digits[dep]);
        for (int i = 0; i < NumToStr[index].size(); i++)
        {
            str[dep] = NumToStr[index][i];
            dfs(dep+1,maxDep,digits);
        }
    }

    vector<string> letterCombinations(string digits)
    {
        int n = digits.size();
        if (n == 0)return result;
        str.resize(n);
        dfs(0,n,digits);
        return result;
    }
};

 LeetCode 401

class Solution {
vector<int> hour = { 1, 2, 4, 8 }, minute = {1,2,4,8,16,32};
public:
    void helper(vector<string> & res, pair<int, int> time, int num, int start_point)
    {
        if (num == 0)
        {
            if (time.second < 10)
                res.push_back(to_string(time.first) + ":0" + to_string(time.second));
            else
                res.push_back(to_string(time.first) + ":" + to_string(time.second));
            return;
        }
        for (int i = start_point; i < hour.size() + minute.size(); i++)
        {
            if (i < hour.size())
            {
                time.first += hour[i];
                if (time.first < 12)
                    helper(res, time, num - 1, i + 1);
                time.first -= hour[i];
            }
            else
            {
                time.second += minute[i - hour.size()];
                if (time.second < 60)
                    helper(res,time,num-1,i+1);
                time.second -= minute[i - hour.size()];
            }
        }
    }
    vector<string> readBinaryWatch(int num)
    {
        vector<string> res;
        helper(res,make_pair(0,0),num,0);
        return res;
    }
    
};

LeetCode 78

class Solution {
public:
    vector<int>ans;
    vector<vector<int>> res;
    vector<vector<int>> subsets(vector<int>& nums) {
        if(nums.empty())return res;
        sort(nums.begin(),nums.end());
        dfs(0,ans,nums);
        return res;
    }
    void dfs(int k,vector<int> ans, vector<int> nums)
    {
        res.push_back(ans);
        for(int i=k;i<nums.size();i++)
        {
            ans.push_back(nums[i]);
            dfs(i+1,ans,nums);
            ans.pop_back();
        }
    }
};

LeetCode 51

class Solution {
private:
    vector<vector<string> > res;
public:
    vector<vector<string> > solveNQueens(int n) {
        vector<string>cur(n, string(n,'.'));
        helper(cur, 0);
        return res;
    }
    void helper(vector<string> &cur, int row)
    {
        if(row == cur.size())
        {
            res.push_back(cur);
            return;
        }
        for(int col = 0; col < cur.size(); col++)
            if(isValid(cur, row, col))
            {
                cur[row][col] = 'Q';
                helper(cur, row+1);
                cur[row][col] = '.';
            }
    }
     
    //判断在cur[row][col]位置放一个皇后，是否是合法的状态
    //已经保证了每行一个皇后，只需要判断列是否合法以及对角线是否合法。
    bool isValid(vector<string> &cur, int row, int col)
    {
        //列
        for(int i = 0; i < row; i++)
            if(cur[i][col] == 'Q')return false;
        //右对角线(只需要判断对角线上半部分，因为后面的行还没有开始放置)
        for(int i = row-1, j=col-1; i >= 0 && j >= 0; i--,j--)
            if(cur[i][j] == 'Q')return false;
        //左对角线(只需要判断对角线上半部分，因为后面的行还没有开始放置)
        for(int i = row-1, j=col+1; i >= 0 && j < cur.size(); i--,j++)
            if(cur[i][j] == 'Q')return false;
        return true;
    }
};

LeetCode 46

class Solution {
private:
    vector<vector<int>> result;
    vector<int> visited;
public:
    void dfs(int st, int n, vector<int>& v, vector<int>& nums)
    {
        if (st == n)
        {
            result.push_back(v);
            return;
        }
        for (int i = 0; i < n; i++)
        {
            if (visited[i] != 1)
            {
                visited[i] = 1;
                v.push_back(nums[i]);
                dfs(st + 1, n,v,nums);
                v.pop_back();
                visited[i] = 0;
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums)
    {
        int num = nums.size();
        visited.resize(num);
        vector<int> tmp;
        dfs(0,num,tmp,nums);
        return result;
    }

};

 LeetCode 47

class Solution {
private:
    vector<vector<int>> result;
    vector<int> tmpResult;
    vector<int> count;
public:
    void dfs(int dep, int maxDep, vector<int>& num, vector<int> visited)
    {
        if (dep == maxDep)
        {
            result.push_back(tmpResult);
            return;
        }
        for (int i = 0; i < num.size(); i++)
        {
            if (i == 0)count[dep] = 0;
            if (!visited[i])
            {
                count[dep]++;
                if (count[dep]>1 && tmpResult[dep] == num[i])continue; 
                // 每个位置第二次选数时和第一次一样则continue
                visited[i] = 1;             // 每个位置第二次选择的数时和第一次不一样  
                tmpResult[dep] = num[i];
                dfs(dep + 1, maxDep, num, visited);
                visited[i] = 0;
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int> &num)
    {
        sort(num.begin(), num.end());
        tmpResult.resize(num.size());
        count.resize(num.size());
        vector<int> visited;
        visited.resize(num.size());
        dfs(0, num.size(), num, visited);
        return result;
    }
};

LeetCode 79

class Solution {
public:
    bool dfs(int xi, int yi, string &word, int index, vector<vector<char> > &board, const int &m, const int &n, int **visited){
        visited[xi][yi] = 1;        // 该结点已经访问过了
        if(index + 1 < word.size()){
            if(xi-1 >= 0 && visited[xi-1][yi]==0 && board[xi-1][yi] == word[index+1]){
                if(dfs(xi-1, yi, word, index+1, board, m, n, visited))return true;   //深度遍历
                visited[xi-1][yi] = 0;      // 这条路行不通 设为未访问 以不影响下面的遍历
            }
            if(xi+1 <m && visited[xi+1][yi]==0 && board[xi+1][yi] == word[index+1]){
                if(dfs(xi+1, yi, word, index+1, board, m, n, visited))return true;
                visited[xi+1][yi] = 0;
            }
            if(yi-1 >= 0 && visited[xi][yi-1]==0 && board[xi][yi-1] == word[index+1]){
                if(dfs(xi, yi-1, word, index+1, board, m, n,visited)) return true;
                visited[xi][yi-1] = 0;
            }
            if(yi+1 < n && visited[xi][yi+1]==0 && board[xi][yi+1] == word[index+1]){
                if(dfs(xi, yi+1, word, index+1, board, m, n,visited)) return true;
                visited[xi][yi+1] = 0;
            }
            return false;
        }else return true;
    }
    
    void initVisited(int ** visited, const int &m, const int &n){
        for(int i = 0; i < m; i++)
            memset(visited[i], 0, sizeof(int)*n);
    }
    bool exist(vector<vector<char> > &board, string word) {
        int m = board.size();
        int n = board[0].size();
        int **visited = new int*[m];
        for(int i = 0; i < m; i++)
            visited[i] = new int[n];
        
        for(int i = 0; i < m; i++){   // 找到其中的i和j
            for(int j = 0; j < n; j++){
                if(word[0] == board[i][j]){
                    initVisited(visited, m, n);
                    if(dfs(i, j, word, 0, board, m, n,visited)) return true;
                }
            }
        }
        for(int i = 0; i < m; i++)
            delete []visited[i];
        delete []visited;
        return false;
    }
};