代码随想录一刷打卡——回溯算法及其剪枝优化

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划刷完卡子哥的刷题计划，加油！
推荐一手卡子哥的刷题网站，感谢卡子哥。代码随想录

一、77. 组合

77. 组合

Note：回溯第一步

class Solution {
private:
  vector<vector<int>> result;
  vector<int> path;

  void backtracking(int n, int k, int startIndex) {
      if (path.size() == k) {
          result.push_back(path);
          return;
      }
      for (int i = startIndex; i <= n; i++) {
          path.push_back(i);
          backtracking(n, k, i + 1);
          path.pop_back();
      }
  }
public:
  vector<vector<int>> combine(int n, int k) {
      result.clear();
      path.clear();
      backtracking(n, k, 1);
      return result;
  }
};

剪纸操作

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++)

二、216. 组合总和 III

216. 组合总和 III

Note：回溯两连，跟77非常像。

class Solution {
private:
  vector<vector<int>> result;
  vector<int> path;

  void backtracking(int targetSum, int k, int sum, int startIndex) {
      if (path.size() == k) {
          if (sum == targetSum) result.push_back(path);
          return;
      }

      for (int i = startIndex; i <= 9; i++) {
          sum += i;
          path.push_back(i);
          backtracking(targetSum, k, sum, i + 1);
          sum -= i;
          path.pop_back();
      }
  }
public:
  vector<vector<int>> combinationSum3(int k, int n) {
      result.clear();
      path.clear();
      backtracking(n, k, 0, 1);
      return result;
  }
};

剪枝：

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (sum > targetSum) return;

        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return;
        }

        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
            sum += i;
            path.push_back(i);
            backtracking(targetSum, k, sum, i + 1);
            sum -= i;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear();
        path.clear();
        backtracking(n, k, 0, 1);
        return result;
    }
};

三、17. 电话号码的字母组合

17. 电话号码的字母组合

Note：字符串与数字互相映射，再回溯

class Solution {
  const string letterMap[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
public:
  vector<string> result;
  string s;
  void backtracking(const string& digits, int index) {
      if (index == digits.size()) {
          result.push_back(s);
          return;
      }
      int digit = digits[index] - '0';
      string letters = letterMap[digit];

      for (int i = 0; i < letters.size(); i++) {
          s.push_back(letters[i]);
          backtracking(digits, index + 1);
          s.pop_back();
      }
  }
  vector<string> letterCombinations(string digits) {
      s.clear();
      result.clear();
      if (digits.size() == 0) {
          return result;
      }
      backtracking(digits, 0);
      return result;
  }
};

四、39. 组合总和

39. 组合总和

Note：跟最开始的递归题没差啥

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum > target) return;
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

剪枝优化很有说法，可以先排个序，然后for循环中值大于的就没必要进入下一层了。

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        sort(candidates.begin(), candidates.end());
        backtracking(candidates, target, 0, 0);
        return result;
    }
};

五、40. 组合总和 II

40. 组合总和 II

Note：维护一个bool数组记录使用数字

class Solution {
private:
  vector<vector<int>> result;
  vector<int> path;
  void backtracking(vector<int> candidates, int target, int sum, int startIndex, vector<bool>& used) {
      if (sum == target) {
          result.push_back(path);
          return;
      }
      for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
          if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false)
              continue;
          sum += candidates[i];
          path.push_back(candidates[i]);
          used[i] = true;
          backtracking(candidates, target, sum, i + 1, used);
          used[i] = false;
          sum -= candidates[i];
          path.pop_back();
      }

  }
public:
  vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
      vector<bool> used(candidates.size(), false);
      path.clear();
      result.clear();

      sort(candidates.begin(), candidates.end());
      backtracking(candidates, target, 0, 0, used);
      return result;
  }
};

六、131. 分割回文串

131. 分割回文串

Note：每次递归判断是否回文

class Solution {
private:
  vector<vector<string>> result;
  vector<string> path;
  void backtracking (const string& s, int startIndex) {
      if (startIndex >= s.size()) {
          result.push_back(path);
          return;
      }
      for (int i = startIndex; i < s.size(); i++) {
          if (isPalindrome(s, startIndex, i)) {
              string str = s.substr(startIndex, i - startIndex + 1);
              path.push_back(str);
          } else {
              continue;
          }
          backtracking(s, i + 1);
          path.pop_back();
      }
  }

  bool isPalindrome(const string& s, int start, int end) {
      for (int i = start, j = end; i < j; i++, j--) {
          if (s[i] != s[j]) 
              return false;
      }
      return true;
  }
public:
  vector<vector<string>> partition(string s) {
      result.clear();
      path.clear();
      backtracking(s, 0);
      return result;
  }
};

七、93. 复原 IP 地址

93. 复原 IP 地址

Note：递归，判断子串是否合法

class Solution {
private:
    vector<string> result;
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) {
            if (isValid(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return;
        }
        for (int i = startIndex; i < s.size(); i++) {
            if (isValid(s, startIndex, i)) {
                s.insert(s.begin() + i + 1, '.');
                pointNum++;
                backtracking(s, i + 2, pointNum);
                pointNum--;
                s.erase(s.begin() + i + 1);
            } else break;
        }
    }
    bool isValid(const string& s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) {
            return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') {
                return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255) {
                return false;
            }
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result;
        backtracking(s, 0, 0);
        return result;
    }
};

八、78. 子集

78. 子集

Note：稍稍修改一下回溯代码就行了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if (root == NULL) return NULL;
        if (root->val < low) {
            TreeNode* right = trimBST(root->right, low, high);
            return right;
        }
        if (root->val > high) {
            TreeNode* left = trimBST(root->left, low, high);
            return left;
        }        
        root->left = trimBST(root->left, low, high);
        root->right = trimBST(root->right, low, high);
        return root;
    }
};

九、90. 子集 II

90. 子集 II

Note：理解“树层去重”和“树枝去重”

class Solution {
private:
  vector<vector<int>> result;
  vector<int> path;
  void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
      result.push_back(path);
      for (int i = startIndex; i < nums.size(); i++) {
          if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
              continue;
          }
          path.push_back(nums[i]);
          used[i] = true;
          backtracking(nums, i + 1, used);
          used[i] = false;
          path.pop_back();
      }
  }
public:
  vector<vector<int>> subsetsWithDup(vector<int>& nums) {
      result.clear();
      path.clear();
      vector<bool> used(nums.size(), false);
      sort(nums.begin(), nums.end());
      backtracking(nums, 0, used);
      return result;
  }
};

十、491. 递增子序列

491. 递增子序列

Note：这题很麻烦，之后得再次学习

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, int startIndex) {
        if (path.size() > 1) {
            result.push_back(path);
        }
        unordered_set<int> uset;
        for (int i = startIndex; i < nums.size(); i++) {
            if ((!path.empty() && nums[i] < path.back()) || uset.find(nums[i]) != uset.end())
                continue;
        uset.insert(nums[i]);
        path.push_back(nums[i]);
        backtracking(nums, i + 1);
        path.pop_back();
        }
    }
public:
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums, 0);
        return result;
    }
};

十一、46. 全排列

46. 全排列

Note：唯一的区别就是可以用重复数字了

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    void backstracking (vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }

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

十二、47. 全排列 II

47. 全排列 II

Note：这题很麻烦，之后得再次学习

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

    void backstracking (vector<int>& nums, vector<bool>& used) {
        if (path.size() == nums.size()) {
            result.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)
                continue;
            if (used[i] == false) {
                used[i] = true;
                path.push_back(nums[i]);
                backstracking(nums, used);
                path.pop_back();
                used[i] = false;
            }
        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        result.clear();
        path.clear();
        sort(nums.begin(), nums.end());
        vector<bool> used(nums.size(), false);
        backstracking(nums, used);
        return result;
    }
};

十三、332. 重新安排行程

332. 重新安排行程

Note：很复杂的一道题，哈希+深搜+回溯

class Solution {
private:
    unordered_map<string, map<string, int>> targets;
    bool backtracking(int ticketNum, vector<string>& result) {
        if (result.size() == ticketNum + 1) {
            return true;
        }

        for (pair<const string, int>& target : targets[result[result.size() - 1]]) {
            if (target.second > 0) {
                result.push_back(target.first);
                target.second--;
                if (backtracking(ticketNum, result)) return true;
                result.pop_back();
                target.second++;
            }
        }
        return false;
    }
public:
    vector<string> findItinerary(vector<vector<string>>& tickets) {
        targets.clear();
        vector<string> result;

        for (const vector<string>& vec : tickets) {
            targets[vec[0]][vec[1]]++;
        }
        result.push_back("JFK");
        backtracking(tickets.size(), result);
        return result;
    }
};

十四、51. N 皇后

51. N 皇后

Note：经典题目N皇后

class Solution {
private:
    vector<vector<string>> result;
    void backtracking(int n, int row, vector<string>& chessboard) {
        if (row == n) {
            result.push_back(chessboard);
            return;
        }
        for (int col = 0; col < n; col++) {
            if (isValid(row, col, chessboard, n)) {
                chessboard[row][col] = 'Q';
                backtracking(n, row + 1, chessboard);
                chessboard[row][col] = '.';
            }
        }
    }
    bool isValid(int row, int col, vector<string>& chessboard, int n) {
        /*检查列*/
        for (int i = 0; i < row; i++) {
            if (chessboard[i][col] == 'Q')
            return false;
        }
        /*检查↗*/
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (chessboard[i][j] == 'Q')
            return false;
        }

        /*检查↖*/
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (chessboard[i][j] == 'Q')
            return false;
        }
        return true;
    }
public:
    vector<vector<string>> solveNQueens(int n) {
        result.clear();
        vector<string> chessboard(n, string(n, '.'));
        backtracking(n, 0, chessboard);
        return result;
    }
};

十五、37. 解数独

37. 解数独

Note：类似与N皇后思想

class Solution {
private:
    bool backtracking(vector<vector<char>>& board) {
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                if (board[i][j] != '.') continue;
                for (char k = '1'; k <= '9'; k++) {
                    if (isValid(i, j, k, board)) {
                        board[i][j] = k;
                        if (backtracking(board)) return true;
                        board[i][j] = '.';
                    }
                }
                return false;
            }
        }
        return true;
    }

bool isValid(int row, int col, char val, vector<vector<char>>& board) {
    /*行判断*/
    for (int i = 0; i < 9; i++) {
        if (board[row][i] == val) {
            return false;
        }
    }
    /*列判断*/
    for (int j = 0; j < 9; j++) {
        if (board[j][col] == val) {
            return false;
        }
    }
    int startRow = (row / 3) * 3;
    int startCol = (col / 3) * 3;
    /*九宫格判断*/
    for (int i = startRow; i < startRow + 3; i++) {
        for (int j = startCol; j < startCol + 3; j++) {
            if (board[i][j] == val)
            return false;
        }
    }
    return true;
}
public:
    void solveSudoku(vector<vector<char>>& board) {
        backtracking(board);
    }
};

总结

回溯是递归的副产品，只要有递归就会有回溯，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。
回溯法就是暴力搜索，并不是什么高效的算法，最多再剪枝一下。
回溯算法也来到了尾声，作为一种并不是很好的暴力算法也同样有其独有的魅力，N皇后和数独我一度认为这能过？但是有些时候暴力确实是没有思路的无奈之举。虽然面试中尽量还是用一些能让人眼前一亮的方法比较好，但是笔试如果没有限制的情况下还是越快越省事才是最优选择。