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

LeetCode 39

  class Solution {
  public:
      void dfs(int dep, int maxDep, vector<int>& cand, int target)
  {
      if (target < )return;
      if (dep == maxDep)
      {
          if (target == )//到达尾部且等于target
          {
               vector<int> temp;
               for (int i = ; i < maxDep; i++)
               {
                 for (int j = ; j < num[i]; j++)
                     temp.push_back(cand[i]);
               }
                 ret.push_back(temp);
             }
             return;
         }
         for (int i = ; i <= target / cand[dep]; i++)//枚举合适的情况
         {
             num[dep] = i;
             dfs(dep + , maxDep, cand, target - i*cand[dep]);
         }
 }
 vector<vector<int>> combinationSum(vector<int>& candidates, int target)
 {
     int n = candidates.size();
     if (n == )return ret;
     sort(candidates.begin(), candidates.end());
     num.resize(n);
     ret.clear();
     dfs(, n, candidates, target);
     return ret;

 }
 private:
     vector<vector<int>> ret;//返回的结果
     vector<int> num;//用来存储每个数字的次数
 };

LeetCode 40

 class Solution {
 public:
 void dfs(int dep, int maxDep, vector<int>& cand, int target)
 {
     if (target < )return;
     if (dep == maxDep)
     {
         if (target == )
         {
               vector<int> temp;
               for (int i = ; i < maxDep; i++)
               {
                 for (int j = ; j < num[i]; j++)
                     temp.push_back(cand[i]);
               }
                 res.insert(temp);
             }
             return;
         }
         for (int i = ; i<=; i++)
         {
             num[dep] = i;
             dfs(dep + , maxDep, cand, target - i*cand[dep]);
         }
 }
 vector<vector<int>> combinationSum2(vector<int>& candidates, int target)
 {
     int n = candidates.size();
     if (n == )return ret;
     sort(candidates.begin(), candidates.end());
     num.resize(n);
     ret.clear();
     dfs(, 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 == ){  // 左括号使用完毕  故全部为右括号
             for(int i = pos; i < *n; i++)
                 str[i] = ')';
             result.push_back(str);
             return;
         }

         if(remain > ){             // remain!=0 说明还可以使用左括号
             str[pos] = '(';
             dfs(pos+, str, left+, remain-, n);
         }
         if(left != ){               // left！=0 表示左边还有左括号没有关闭，故可以使用)
             str[pos] = ')';
             dfs(pos+, str, left-, remain, n);
         }
     }
     vector<string> generateParenthesis(int n) {
         string str;
         str.resize(*n);
         dfs(, str, , 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 + , n, k, count);//不取当前数
         }
         tmp[count] = dep + ;         //取当前数
         dfs(dep + , n, k, count+);

     }
     vector<vector<int>> combine(int n, int k)
     {
         if (k>n)k = n;
         tmp.resize(k);
         dfs(, n, k, );
         return result;
     }

 };

LeetCode 17

 string NumToStr[] = {"", "","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 = ; i < NumToStr[index].size(); i++)
         {
             str[dep] = NumToStr[index][i];
             dfs(dep+,maxDep,digits);
         }
     }

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

LeetCode 401

 class Solution {
 vector<int> hour = { , , ,  }, minute = {,,,,,};
 public:
     void helper(vector<string> & res, pair<int, int> time, int num, int start_point)
     {
         if (num == )
         {
             if (time.second < )
                 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 < )
                     helper(res, time, num - , i + );
                 time.first -= hour[i];
             }
             else
             {
                 time.second += minute[i - hour.size()];
                 if (time.second < )
                     helper(res,time,num-,i+);
                 time.second -= minute[i - hour.size()];
             }
         }
     }
     vector<string> readBinaryWatch(int num)
     {
         vector<string> res;
         helper(res,make_pair(,),num,);
         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(,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+,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, );
         return res;
     }
     void helper(vector<string> &cur, int row)
     {
         if(row == cur.size())
         {
             res.push_back(cur);
             return;
         }
         for(int col = ; col < cur.size(); col++)
             if(isValid(cur, row, col))
             {
                 cur[row][col] = 'Q';
                 helper(cur, row+);
                 cur[row][col] = '.';
             }
     }

     //判断在cur[row][col]位置放一个皇后，是否是合法的状态
     //已经保证了每行一个皇后，只需要判断列是否合法以及对角线是否合法。
     bool isValid(vector<string> &cur, int row, int col)
     {
         //列
         for(int i = ; i < row; i++)
             if(cur[i][col] == 'Q')return false;
         //右对角线(只需要判断对角线上半部分，因为后面的行还没有开始放置)
         for(int i = row-, j=col-; i >=  && j >= ; i--,j--)
             if(cur[i][j] == 'Q')return false;
         //左对角线(只需要判断对角线上半部分，因为后面的行还没有开始放置)
         for(int i = row-, j=col+; i >=  && 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 = ; i < n; i++)
         {
             if (visited[i] != )
             {
                 visited[i] = ;
                 v.push_back(nums[i]);
                 dfs(st + , n,v,nums);
                 v.pop_back();
                 visited[i] = ;
             }
         }
     }
     vector<vector<int>> permute(vector<int>& nums)
     {
         int num = nums.size();
         visited.resize(num);
         vector<int> tmp;
         dfs(,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 = ; i < num.size(); i++)
         {
             if (i == )count[dep] = ;
             if (!visited[i])
             {
                 count[dep]++;
                 if (count[dep]> && tmpResult[dep] == num[i])continue;
                 // 每个位置第二次选数时和第一次一样则continue
                 visited[i] = ;             // 每个位置第二次选择的数时和第一次不一样
                 tmpResult[dep] = num[i];
                 dfs(dep + , maxDep, num, visited);
                 visited[i] = ;
             }
         }
     }
     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(, 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] = ;        // 该结点已经访问过了
         if(index +  < word.size()){
             if(xi- >=  && visited[xi-][yi]== && board[xi-][yi] == word[index+]){
                 if(dfs(xi-, yi, word, index+, board, m, n, visited))return true;   //深度遍历
                 visited[xi-][yi] = ;      // 这条路行不通 设为未访问 以不影响下面的遍历
             }
             if(xi+ <m && visited[xi+][yi]== && board[xi+][yi] == word[index+]){
                 if(dfs(xi+, yi, word, index+, board, m, n, visited))return true;
                 visited[xi+][yi] = ;
             }
             if(yi- >=  && visited[xi][yi-]== && board[xi][yi-] == word[index+]){
                 if(dfs(xi, yi-, word, index+, board, m, n,visited)) return true;
                 visited[xi][yi-] = ;
             }
             if(yi+ < n && visited[xi][yi+]== && board[xi][yi+] == word[index+]){
                 if(dfs(xi, yi+, word, index+, board, m, n,visited)) return true;
                 visited[xi][yi+] = ;
             }
             return false;
         }else return true;
     }

     void initVisited(int ** visited, const int &m, const int &n){
         for(int i = ; i < m; i++)
             memset(visited[i], , sizeof(int)*n);
     }
     bool exist(vector<vector<char> > &board, string word) {
         int m = board.size();
         int n = board[].size();
         int **visited = new int*[m];
         for(int i = ; i < m; i++)
             visited[i] = new int[n];

         for(int i = ; i < m; i++){   // 找到其中的i和j
             for(int j = ; j < n; j++){
                 if(word[] == board[i][j]){
                     initVisited(visited, m, n);
                     if(dfs(i, j, word, , board, m, n,visited)) return true;
                 }
             }
         }
         for(int i = ; i < m; i++)
             delete []visited[i];
         delete []visited;
         return false;
     }
 };