LeetCode刷题day12——回溯法

头疼，想不明白前真的想不明白，想明白了是真的明白了，我要吐了。。。。

93. 复原IP地址

有效 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

• 例如："0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址，但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

示例 3：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

• 1 <= s.length <= 20
• s 仅由数字组成

代码：

思路写在注释里，麻了麻了

class Solution {
public:
    vector<string> res;
    string combine;

    void backtracking(string s, int sumdot) {
        if (s.length() == 0 && sumdot == 4) {//注意这里的&&，和4
            int len=combine.length();
            if(combine[len-1]=='.')
                combine.pop_back();
            res.emplace_back(combine);
            return;
        }
        if(s.length()==0||sumdot==4) {
            return;
        }
        for (int i = 1; i <= s.length()&&i<=3; i++) {//i <= s.length()&&i<=3注意这个条件，=！！！！为此卡了很久，还有<=3这个条件，分割的字符，最多是三位数
            string tmp = s.substr(0, i);
            if (tmp[0] == '0' && tmp.length() > 1)
                continue;

            int num = stoi(tmp);
            if (num > 255)
                continue;
            string tmp2 = combine;
            combine.append(tmp + '.');
            backtracking(s.substr(i), sumdot+1);//这样传参，1. 直接切割字符，要求是参数不能引用。2. sumdot其实是段数，分成四段，+1传参这样就不用复原
            combine = tmp2;
        }
    }

    vector<string> restoreIpAddresses(string s) {
        if (s.length() < 4 || s.length() > 12)  // 如果字符串长度不在 4 到 12 之间，直接返回空
            return res;
       
        int sumdot = 0;
        backtracking(s, sumdot);
        return res;
    }
};

78. 子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的

子集

（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

代码：

这不是很简单马？马失前蹄，我真的。。。。。

被gpt修复了，但是有的我还没时间改：

• 你的代码问题在于以下几个方面：

1. 重复子集问题：
   • 在 backtracking(nums, start+1); 中，你没有正确递增 start 的值，而是始终传入 start+1。这导致在递归中同一个元素被重复选择，出现了重复的子集。（实在致命的问题，想了好久才想通）
2. 逻辑问题：
   • uniq 用于去重，但是直接用 set 存储 path 来去重不是最佳方法，问题的本质是如何避免重复，而不是依赖于结果后期处理。（说得好）
3. 多余逻辑：
   • 在 subsets 函数中你手动添加了空集，但实际上在回溯过程中，空集会自然地包含，不需要手动插入。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    set<vector<int>> uniq;
    void backtracking(const vector<int> & nums,int start) {
       // cout<<"backtracking"<<endl;
        if(path.size()<=nums.size()) {
            uniq.insert(path);
        }
        if(path.size()==nums.size()) {
            return;
        }

        for(int i = start; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums,i+1);//backtracking(nums,start+1);这是错的，在这里卡住了，正确的写法，理解为：在深度上来看，是不会出现重复选择的，比如选1，剩下的以1为父节点的子树，是不会再选到1
            //错误的地方在于：之前i=1已经执行过。此时i=2，但是start=0,意思是，在选择第一层树时，第二个孩子应该是2往后选，但是因为还是之前的start所以，这个时候，第二层还是从1开始选的，造成重复
            path.pop_back();
        }
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums,0);
        vector<int> tmp;
        uniq.insert(tmp);
        res.assign(uniq.begin(), uniq.end());

        return res;
    }
};