代码随想录算法训练营第二十七天|Leetcode93 复原IP地址、Leetcode78 子集、Leetcode90 子集II

● Leetcode93 复原IP地址

题目链接：Leetcode93 复原IP地址
视频讲解：代码随想录|复原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 仅由数字组成

● 解题思路

本题是复原IP地址，因此除了分割字符串让其符合一个IP地址的形式（子字段之间用’.'分隔）之外，我们还需要对IP的合法性进行检验。
IP地址通常由四个字段组成，且每个字段需要符合：

1.字段内第一个数字不能为0，否则为不合法IP地址；
2.字段整体大小不能超过255，否则为不合法IP地址；
3.字段内由[0, 9]组成，不包含非负整数，否则为不合法IP地址。

而对于划分的原字符串，同时还需要满足4 <= 字符个数 <= 12。

依照回溯三部曲：
（1）确定回溯函数的参数和返回值：
参数传入字符串s，startIndex作为分割位置标记，同时还需要传入pointSum记录分割的子段数；返回值为void；
（2）确定回溯函数的终止条件：
将原字符串复原成IP地址以后，我们需要使用三个’.‘将其分割成四个字段，也就是说我们可以通过记录’.‘的个数判断什么时候应该终止，当pointSum == 3时，我们对最后一个子段进行合法性检验，如果合法，则IP地址被复原，负责继续向下进行递归回溯；
（3）确定单层遍历逻辑：
每一层递归的分割我们依然使用startIndex标记，在进行具体操作之前我们需要对[ startIndex, i]字段内合法性检验，如果合法，我们就再次进行划分，同时为了满足IP格式要求，需要在s.begin() + i + 1处插入’.'，并对pointSum自加。

● 代码实现

class Solution {
private:
    vector<string> result;

    void backtracking(string& s, int startIndex, int pointSum)
    {
        //终止条件
        if(pointSum == 3)
        {
            if(isValid(s, startIndex, s.size() - 1))
            {
                result.push_back(s);
            }
            return;
        }
        for(int i = startIndex; i < s.size(); i++)
        {
            if(isValid(s, startIndex, i))
            {
                s.insert(s.begin() + i + 1, '.');
                pointSum++;
                backtracking(s, i + 2, pointSum);
                s.erase(s.begin() + i + 1);
                pointSum--;
            }
            else break;
        }
    }

    bool isValid(string& s, int start, int end)
    {
        //操作范围不合法
        if(start > end) return false;
        //子段内首数字为'0'，ip格式不合法
        if(s[start] == '0' && start != end) return false;
        int num = 0;
        for(int i = start; i <= end; ++i)
        {
            //非数字字符不合法
            if(s[i] < '0' || s[i] > '9') return false;
            num = num * 10 + (s[i] - '0');
            //子段内数字大于255，ip格式不合法
            if(num > 255) return false;
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        if (s.size() < 4 || s.size() > 12) return result;
        backtracking(s, 0, 0);
        return result;
    }
};

● Leetcode78 子集

题目链接：Leetcode78 子集
视频讲解：代码随想录|子集
题目描述：给你一个整数数组 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 中的所有元素 互不相同

● 解题思路

对于之前遇到的回溯问题，都是在叶子结点处收集结果，但对于子集问题，每一个结点处的结果都需要进行收集；
（1）确定回溯函数的参数和返回值：
参数传入数组容器vector<int>& nums，startIndex传入下一层循环开始的位置；返回值为void;
（2）确定回溯函数的终止条件：
当startIndex >= nums.size()的时候，即遍历完整个数组容器，此时return；
但同时还需要考虑收集结果需要在终止条件之前还是之后？
假如收集结果在终止条件之后，当遍历到最后一个元素时，则直接返回到上一层，对于全集结果无法正常收集，因此需要在进入回溯函数的时候就需要立刻收集结果；
（3）确定单层遍历逻辑：
每进入一层递归，将第一个剩余元素加入到path中，随后进入下一层递归，退出时将加入元素弹出。

● 代码实现

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;

    void backtracking(vector<int>& nums, int startIndex)
    {
        result.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) {
        backtracking(nums, 0);
        return result;
    }
};

● Leetcode90 子集II

题目链接：Leetcode90 子集II
视频讲解：代码随想录|子集II
题目描述：给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的
子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：
输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2：
输入：nums = [0]
输出：[[],[0]]

提示：
1 <= nums.length <= 10
-10 <= nums[i] <= 10

● 解题思路

子集II是对子集和组合总和II的一个合并，除了需要借助startIndex去除类似[1, 2]和[2, 1]这样的重复组合，因为数组中还有重复元素，我们需要进行像组合总和II一样进行树层去重；
我们定义vector<bool> used(nums.size(), 0)对元素进行标记，同一层中选择相同元素时，后续递归结果相同，而树枝上可以选择相同元素，不会产生相同后续结果。

（1）确定回溯函数的参数和返回值：
参数传入vector<int> nums，startIndex避免重复组合情况，used对遍历过元素进行标记，进行树层去重；
（2）确定回溯函数的终止条件：
当元素遍历到最后一个元素时，就需要return；
（3）确定单层遍历逻辑：
当满足条件i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false，即在同树层上出现相同元素，需要进行去重；将遍历元素加入path中的同时，还需要将used[i]置为true，随后进入下一层递归。

● 代码实现

class Solution {
private:
    vector<int> path;
    vector<vector<int>> result;

    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used)
    {
        result.push_back(path);
        if(startIndex >= nums.size())
        {
            return;
        }

        for(int i = startIndex; i < nums.size(); i++)
        {
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)
            {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
        }
    }
public:
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, 0, used);
        return result;
    }
};