[刷题笔记27 回溯算法 part03]

回溯算法

● 39. 组合总和
● 40.组合总和II
● 131.分割回文串

组合总和

39. 组合总和

法1：回溯

    vector<int> path;
    vector<vector<int>> ans;
    void  backTracking(vector<int> nums,int targrtSum, int sum,int startIndex){
         if (sum == targrtSum) {
            ans.push_back(path);
            return;
        }
        for (int i = startIndex; i < nums.size() && sum + nums[i] <= targrtSum; ++i) {
            sum += nums[i];
            path.push_back(nums[i]);
            backTracking(nums,targrtSum,sum,i);//迭代
            sum -= nums[i];//回溯
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        path.clear();
        ans.clear();
        sort(candidates.begin(), candidates.end()); // 需要排序
        backTracking(candidates,target,0,0);
        return ans;
    }

组合总和II

40.组合总和II
法1： 回溯

  vector<int> path;
    vector<vector<int>> ans;
    void backTracking(vector<int>& nums,int target,int sum, int startIndex, vector<bool>& used){
        //终止条件
        if (sum == target) {
            ans.push_back(path);
            return;
        }
        //单层循环逻辑   剪枝
        for (int i = startIndex; i < nums.size() && sum + nums[i] <= target; ++i) {
            // 要对同一树层使用过的元素进行跳过
            if (i > 0  && nums[i] == nums[i - 1] && !used[i - 1]) continue;
            sum += nums[i];
            path.push_back(nums[i]);
            used[i] = true;
            backTracking(nums,target,sum,i+1,used);
            sum -= nums[i];
            path.pop_back();//回溯
            used[i] = false;
        }
        return;
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        vector<bool> used(candidates.size(),false);
        path.clear();
        ans.clear();
        // 首先把给candidates排序，让其相同的元素都挨在一起。
        sort(candidates.begin(),candidates.end());
        backTracking(candidates,target,0,0,used);
        return ans;
    }

分割回文串

131.分割回文串

法1：回溯

    bool isHuiwen(string s1,int start,int end){
//        for (int i = start,j = end; i < j; ++i, j--) {
//            if (s1[i] != s1[j]) return false;
//        }
//        return true;
//    }
//    void backTracking(string s,int startIndex){
//        //终止条件
//        if (startIndex >= s.length()) {
//            ans.push_back(path);
//            return;
//        }
//        //单层循环逻辑
//        for (int i = startIndex; i < s.length(); ++i) {
//
//            //判断回文
//            if (isHuiwen(s, startIndex, i)) {
//                string s1 = s.substr(startIndex, i - startIndex + 1);
//                path.push_back(s1);
//            } else{
//                //缺失沿着纵向发展
//                continue;
//            }
//            backTracking(s, i + 1);
//            path.pop_back();//回溯
//        }
//    }
    vector<vector<string>> partition(string s) {
        path.clear();
        ans.clear();
        computeIsHuiWen(s);
        backTracking(s,0);
        return ans;
    }

法2：动态规划优化

    vector<vector<string>>ans;
    vector<string> path;
    //动态规划优化判断回文字符串
    vector<vector<bool>>isHuiwen;
    void backTracking(string s,int startIndex){
        //终止条件
        if (startIndex >= s.length()) {
            ans.push_back(path);
            return;
        }
        //单层循环逻辑
        for (int i = startIndex; i < s.length(); ++i) {

            //判断回文
            if (isHuiwen[startIndex][i]) {
                string s1 = s.substr(startIndex, i - startIndex + 1);
                path.push_back(s1);
            } else{
                //缺失沿着纵向发展
                continue;
            }
            backTracking(s, i + 1);
            path.pop_back();//回溯
        }
    }
    void computeIsHuiWen(string& s){//形成n*n矩阵，元素值为s[i:j]是否是回文字符串
        isHuiwen.resize(s.size(), vector<bool>(s.size(), false)); // 根据字符串s, 刷新布尔矩阵的大小
        for (int i =  s.size()-1; i >=0; i--) {
            for (int j = i; j < s.size(); ++j) {
                if (i == j) isHuiwen[i][j] = true;//对角线
                else if (j - i == 1) isHuiwen[i][j] = (s[i] == s[j]);//对角线对应元素的上一行元素
                else { isHuiwen[i][j] = (s[i] == s[j] && isHuiwen[i + 1][j - 1]); }//下三角
            }
        }
    }
    
    vector<vector<string>> partition(string s) {
        path.clear();
        ans.clear();
        computeIsHuiWen(s);
        backTracking(s,0);
        return ans;
    }