day27打卡

day27打卡

39. 组合总和

• 画出决策树

• 函数头：void dfs(vector< int >& candidates, int target, int pos, int sum)

• 函数体：

​ 出口：如果pos与candidates的长度相等，返回即可

​ 子问题：每次从pos位置开始寻找，找到和等于target时，保存结果。

​ 回溯：每次将path中的最后存入的元素pop掉

​ 剪枝：和等于target，保存结果然后返回。得到的和大于target，也返回。

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        dfs(candidates, target, 0, 0);
        return ret;
    }
    void dfs(vector<int>& candidates, int target, int pos, int sum)
    {
        if(sum > target) return;
        //出口
        if(sum == target)
        {
            ret.push_back(path);
            return;
        }
        if(pos == candidates.size()) return;
        //子问题
        for(int i = pos; i < candidates.size(); i++)
        {
            path.push_back(candidates[i]);
            //回溯
            dfs(candidates, target, i, sum + candidates[i]);
            path.pop_back();
        }
    }
};

40. 组合总和 II

为什么 if(i > pos && candidates[i] == candidates[i-1])可以避免重复

• 首先 cur-1 == cur 是用于判定当前元素是否和之前元素相同的语句。这个语句就能砍掉例1。
  可是问题来了，如果把所有当前与之前一个元素相同的都砍掉，那么例二的情况也会消失。 
  因为当第二个2出现的时候，他就和前一个2相同了。
                  
  那么如何保留例2呢？
  那么就用cur > begin 来避免这种情况，你发现例1中的两个2是处在同一个层级上的，
  例2的两个2是处在不同层级上的。
  在一个for循环中，所有被遍历到的数都是属于一个层级的。我们要让一个层级中，
  必须出现且只出现一个2，那么就放过第一个出现重复的2，但不放过后面出现的2。
  第一个出现的2的特点就是 cur == begin. 第二个出现的2 特点是cur > begin.
  

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(), candidates.end());
        dfs(candidates, target, 0, 0);
        return ret;
    }
    void dfs(vector<int>& candidates, int target, int pos, int sum)
    {
        //剪枝
        if(sum > target) return;
        //出口
        if(target == sum)
        {
            ret.push_back(path);
            return;
        }
        if(pos == candidates.size()) return;
        //子问题
        for(int i = pos; i < candidates.size(); i++)
        {
            if(i > pos && candidates[i] == candidates[i-1])
                continue;
            path.push_back(candidates[i]);
            //回溯
            dfs(candidates, target, i+1, sum + candidates[i]);
            path.pop_back();
        }
    }
};

131. 分割回文串

思路见代码

class Solution {
public:
    vector<vector<string>> ret;
    vector<string> path;
    vector<vector<string>> partition(string s) {
        dfs(s);
        return ret;
    }
    void dfs(string s)
    {
        // 当字符串 s 为空时，表示已经遍历完成一条路径，将其添加到结果集中
        if (s.size() == 0) 
        {
            ret.push_back(path);
            return;
        }
        // 遍历字符串 s 的每个字符，尝试将其作为回文串的起始字符
        for (int i = 1; i <= s.size(); i++) 
        {
            // 截取字符串 s 的前 i 个字符作为回文串的起始部分
            string pre = s.substr(0, i);
            // 判断截取的部分是否为回文串
            if (isPalindrome(pre)) 
            {
                // 将回文串添加到当前路径中
                path.push_back(pre);
                // 继续递归搜索剩余部分
                dfs(s.substr(i));
                // 回溯，将当前回文串从路径中移除
                path.pop_back();
            }
        }
    }
     // 判断字符串是否为回文串的函数
    bool isPalindrome(string& s) 
    {
        // 如果字符串为空，则认为是回文串
        if (s.size() == 0) return true;
        // 使用双指针法，从字符串的两端向中间遍历
        int start = 0, end = s.size() - 1;
        while (start <= end) 
        {
            // 如果两端字符不相等，则不是回文串
            if (s[start] != s[end])
                return false;
            // 移动指针
            start++;
            end--;
        }
        // 如果遍历完成，则是回文串
        return true;
    }
};

        return false;
        // 移动指针
        start++;
        end--;
    }
    // 如果遍历完成，则是回文串
    return true;
}

};