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

最新推荐文章于 2024-06-18 18:16:56 发布

努力找工作的小菜鸡

最新推荐文章于 2024-06-18 18:16:56 发布

阅读量99

点赞数

分类专栏：代码随想录刷刷刷文章标签：算法剪枝学习 websocket 程序人生

本文链接：https://blog.csdn.net/qq_43264167/article/details/133553104

版权

代码随想录刷刷刷专栏收录该内容

75 篇文章 0 订阅

订阅专栏

文章目录

前言
一、77. 组合
二、216. 组合总和 III
三、17. 电话号码的字母组合
四、39. 组合总和
五、40. 组合总和 II
六、131. 分割回文串
七、93. 复原 IP 地址
八、78. 子集
九、90. 子集 II
十、491. 递增子序列
十一、46. 全排列
十二、47. 全排列 II
十三、332. 重新安排行程
十四、51. N 皇后
十五、37. 解数独
总结

前言

一个本硕双非的小菜鸡，备战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皇后和数独我一度认为这能过？但是有些时候暴力确实是没有思路的无奈之举。虽然面试中尽量还是用一些能让人眼前一亮的方法比较好，但是笔试如果没有限制的情况下还是越快越省事才是最优选择。