Day23 回溯专项

39. 组合总和

class Solution {
private:
    vector<vector<int>> ret_;
    vector<int> path_;
    int sum_ = 0;

public:
    void backTracking(const vector<int>& candidates, const int &target, int index) {
        if (sum_ == target) {
            ret_.push_back(path_);
            return;
        } else if (sum_ > target) {
            return;
        }

        // && 后面的条件仅在candidates有序时才可如此使用
        for (int i = index; i < candidates.size() && sum_ + candidates[i] <= target; i++) {
            path_.push_back(candidates[i]);
            sum_ += candidates[i];
            backTracking(candidates, target, i); // 因为元素可重复，不要参数为i，而不是i+1
            sum_ -= candidates[i];
            path_.pop_back();
        }
    }

    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        backTracking(candidates, target, 0);
        return ret_;
    }

};

40. 组合总和 II

class Solution {
private:
    vector<vector<int>> ret_;
    vector<int> path_;
    int sum_ = 0;
    vector<bool> used_;

public:
    void backTracking(const vector<int>& candidates, const int &target, int startIndex) {
        if (sum_ == target) {
            ret_.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;
            }
            path_.push_back(candidates[i]);
            sum_ += candidates[i];
            used_[i] = true;
            backTracking(candidates, target, i + 1);
            used_[i] = false;
            sum_ -= candidates[i];
            path_.pop_back();
        }
    }

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        used_.resize(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        backTracking(candidates, target, 0);
        return ret_;
    }
};

131. 分割回文串

class Solution {
 private:
  vector<vector<string>> ret_;
  vector<string> path_;

 public:
  bool isPalindrome(const string &s, int left, int right) {
    for (; left < right; left++, right--) {
      if (s[left] != s[right]) return false;
    }
    return true;
  }

  void backTracking(string s, int startIndex) {
    if (startIndex >= s.size()) {
      ret_.push_back(path_);
      return;
    }

    for (int i = startIndex; i < s.size(); i++) {
      if (isPalindrome(s, startIndex, i)) {
        path_.push_back(s.substr(startIndex, i - startIndex + 1));
      } else {
        continue;
      }

      backTracking(s, i + 1);
      path_.pop_back();
    }
  }

  vector<vector<string>> partition(string s) {
    backTracking(s, 0);
    return ret_;
  }
};