回溯第二天

39. 组合总和

class Solution {
public:
    vector<vector<int>> result;
    vector<int> temp;
    void backTracking(int startIndex, int& Sum, vector<int>& candidates, int target)
    {
        if(Sum > target) return;
        if(Sum == target)
        {
            result.push_back(temp);
            return;
        } 
        for(int i = startIndex; i < candidates.size(); i++)
        {
            Sum += candidates[i];
            temp.push_back(candidates[i]);  
            backTracking(i, Sum, candidates, target);
            temp.pop_back();
            Sum -= candidates[i];
        }

    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        int Sum = 0;
        backTracking(0, Sum, candidates, target);
        return result;
    }
};

40. 组合总和 II

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

    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        int Sum = 0;
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        backTracking(0, Sum, candidates, target, used);
        return result;
    }
};

131. 分割回文串

class Solution {
public:
    
    vector<string> path;
    vector<vector<string>> result;
    bool isPalindrome(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;
    }
    void backTracking(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))
            {
                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 result;
    }
};