回溯算法：复原IP地址子集子集II

暁_

已于 2023-12-06 10:37:32 修改

阅读量970

点赞数 17

文章标签：算法数据结构 leetcode

于 2023-12-06 09:00:00 首次发布

本文链接：https://blog.csdn.net/m0_59425585/article/details/134807591

版权

93.复原IP地址

思路：
- 与分割回文串相似，复原ip地址是将给定字符串分割成点分十进制的四段，切割问题就可以使用回溯搜索法把所有可能性搜出来。
- 回溯三部曲：
  - 递归参数：除了传入的需要分割的字符串，仍然需要startIndex保证不会重复分割，还需要一个变量pointNum来记录已添加的逗点数量。
  - 终止条件：当分割出四段，也就是逗点数量记录为3时，说明分割结束。再验证最后一段的合法性，若合法就可以加入结果集中。前三段的合法性在添加逗点之前判断，因为最后一段之后没有逗点了，所以要单独判断。
  - 单层逻辑：在for循环中，判断截取的左闭右闭区间子串 [startIndex, i] 合法后，在后面一位加上‘ . ’表示已经分割，记录分隔符的变量pointNum加一，再从‘ . ’的下一位开始继续递归，回溯时将‘ . ’再删除，pointNum减一。如果不合法，结束本层循环。
- 判断子串是否合法：
  - 以0开头，但不只有0一个字符的子串不合法
  - 含有非0-9字符的子串不合法
  - 大于255的不合法
- 剪枝：输入长度不合法的字符串时(主函数中)，子串不合法时剪枝(isValid)。
- 时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。
- 空间复杂度: O(n)

class Solution {
private:
    vector<string> res;
    //startIndex记录起始位置(切割线)，pointNum记录已添加的逗点数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if(pointNum == 3) {//如果已添加三个逗点，说明已经切割成四段，切割完毕
            //判断切割的最后一段的合法性，合法就收集结果
            if(isValid(s, startIndex, s.size() - 1)) {
                res.push_back(s);
                return;
            }
        }

        for(int i = startIndex; i < s.size(); i++) {
            if(isValid(s, startIndex, i)) {//判断[startIndex, i]这一段的合法性，合法才继续向下执行递归逻辑，否则直接结束本层循环
                s.insert(s.begin() + i + 1, '.');//在这一字段后面添加逗点
                pointNum++;//逗点计数加一
                backtracking(s, i + 2, pointNum);//递归，从逗点后一位作为新的起始位置，所以是i+2
                pointNum--;//回溯
                s.erase(s.begin() + i + 1);//回溯
            } else break;
        }
    }

    //判断左闭右闭区间[start, end]字符串的合法性
    bool isValid(const string& s, int start, int end) {
        if(start > end) return false;
        //以0开头，但不只有0一个字符的区间不合法
        if(s[start] == '0' && start != end) return false;
        int num = 0;
        for(int i = start; i <= end; i++) {
            if(s[i] > '9' || s[i] < '0') return false;//非数字字符不合法
            num = num * 10 + (s[i] - '0');
            if(num > 255) return false;//大于255则不合法
        }
        return true;
    }

public:
    vector<string> restoreIpAddresses(string s) {
        res.clear();
        if(s.size() < 4 || s.size() > 12) return res;//传入字符串的长度不合法
        backtracking(s, 0, 0);
        return res;
    }
};

78.子集

思路：
- 子集问题是找树的所有节点。
- 集合是无序的，子集{1,2} 和子集{2,1}是一样的，取过的元素不会重复取，写回溯算法的时候，for就要从startIndex开始。求排列问题的时候，就要从0开始，因为集合是有序的，{1, 2} 和{2, 1}是两个集合。
- 回溯三部曲：
  - 函数参数：除了输入的数组，还需要startIndex。
  - 终止条件：剩余集合为空的时候，就是叶子节点，此时startIndex已经大于数组的长度了，终止递归。其实可以不需要加终止条件，因为startIndex >= nums.size()，本层for循环本来也结束了，也不会导致无限递归。
  - 单层逻辑：求取子集问题，不需要任何剪枝，因为子集就是要遍历整棵树。
- 何时收集结果？
  - 我自己实现时的思路是每次path收集完一个元素，就收集一个结果，在主函数中单独收集空集。后面学习到把收集子集放在终止条件之前，就可以不用单独处理空集，也不会漏掉集合本身这个子集。
- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, int startIndex) {
        res.push_back(path);//收集子集，要放在终止添加的上面，否则会漏掉自己本身这个子集
        //if(startIndex == nums.size()) return;//终止条件可以不加
        for(int i = startIndex; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsets(vector<int>& nums) {
        path.clear();
        res.clear();
        backtracking(nums, 0);
        return res;
    }
};

90.子集II

思路：
- 本题与78.子集的区别在于输入集合有重复元素，而要求输出的子集要去重，在40.组合总和II中，已经学习了如何处理这样的情况：首先要排序，为了让值相等的元素相邻，在横向遍历(for循环)时判断当前元素是否与前一个元素值相等，若相等，则跳过搜索。

class Solution {
private:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, int startIndex) {
        res.push_back(path);
        //if(startIndex >= nums.size()) return;
        for(int i = startIndex; i < nums.size(); i++) {
            //横向遍历时，值相同的两个元素不重复选取，实现去重
            if(i > startIndex && nums[i] == nums[i - 1]) continue;
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        path.clear();
        res.clear();
        sort(nums.begin(), nums.end());//排序方便去重
        backtracking(nums, 0);
        return res;
    }
};