练习题（2024/4/27）

@干吧jyb

已于 2024-04-27 23:32:47 修改

阅读量768

点赞数 11

文章标签：算法 leetcode 职场和发展

于 2024-04-27 23:25:32 首次发布

本文链接：https://blog.csdn.net/m0_74859128/article/details/138257207

版权

1复原 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 仅由数字组成

思路：

本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件。

pointNum表示逗点数量，pointNum为3说明字符串分成了4段了。

回溯算法的思路是通过尝试所有可能的IP地址分割方法来解决问题。具体来说，我们从输入字符串的起始位置开始，每次尝试在当前位置插入一个点，然后递归地尝试下一个位置。在递归的过程中，我们需要判断当前分割的子字符串是否合法，包括子字符串是否以0开头（除了0本身外），是否在0到255之间等。当插入了三个点后，我们再判断剩余的字符串是否合法，如果是的话就将该分割方法添加到结果集中。

具体来说，我们首先定义一个私有变量result来存储所有合法的IP地址字符串。然后编写一个私有函数backtracking来进行回溯搜索。在backtracking函数中，我们通过一个循环遍历所有可能的分割位置，对每个位置判断是否合法，如果合法就插入一个点并继续递归搜索下一个位置。当插入了三个点后，我们再判断剩余的字符串是否合法，如果是的话就将该分割方法添加到result中。

在判断子字符串是否合法的过程中，我们需要注意首先判断是否以0开头（除了0本身外），然后再判断是否在0到255之间。如果子字符串满足这些条件，则返回true，否则返回false。

最后，在restoreIpAddresses函数中，我们清空结果集并进行一些简单的剪枝操作，然后调用backtracking函数开始搜索所有可能的合法IP地址分割方法。最终返回结果集result。

判断子串是否合法

主要考虑到如下三点：

段位以0为开头的数字不合法
段位里有非正整数字符不合法
段位如果大于255了不合法

代码：

class Solution {
private:
    vector<string> result;// 记录结果
    // startIndex: 搜索的起始位置，pointNum:添加逗点的数量
    void backtracking(string& s, int startIndex, int pointNum) {
        if (pointNum == 3) { // 逗点数量为3时，分隔结束
            // 判断第四段子字符串是否合法，如果合法就放进result中
            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)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                s.insert(s.begin() + i + 1 , '.');  // 在i的后面插入一个逗点
                pointNum++;
                backtracking(s, i + 2, pointNum);   // 插入逗点之后下一个子串的起始位置为i+2
                pointNum--;                         // 回溯
                s.erase(s.begin() + i + 1);         // 回溯删掉逗点
            } else break; // 不合法，直接结束本层循环
        }
    }
    // 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
    bool isValid(const string& s, int start, int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) { // 0开头的数字不合法
                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) { // 如果大于255了不合法
                return false;
            }
        }
        return true;
    }
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
        backtracking(s, 0, 0);
        return result;
    }
};

2子集

给你一个整数数组 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 中的所有元素 互不相同

思路：

通过回溯算法来搜索所有可能的子集，具体步骤如下：

初始化空的路径path和结果集result。
调用backtracking函数进行回溯：
- 将当前路径path加入到结果集result中。
- 如果当前位置startindex大于等于nums数组的大小，说明已经遍历完所有元素，返回。
- 遍历所有可能的选择，将选择加入路径中，然后递归下一层。
- 回溯，将当前选择移除路径，继续尝试其他选择。
调用主函数subsets：
- 清空当前路径path和结果集result。
- 调用回溯函数backtracking开始搜索所有可能的子集。
- 返回最终结果集result。

代码：

class Solution {
public:
    vector<int> path; // 存储当前路径的数组
    vector<vector<int>> result; // 存储所有子集的数组

    // 回溯函数，startindex表示当前遍历的起始位置
    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(); // 回溯，将当前元素从路径中移除
        }
    }

    // 主函数，返回所有子集
    vector<vector<int>> subsets(vector<int>& nums) {
        path.clear(); // 清空当前路径
        result.clear(); // 清空结果集
        backtracking(nums, 0); // 调用回溯函数
        return result; // 返回结果集
    }
};

3子集 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

思路：

解题思路是使用回溯算法来搜索所有可能的子集，并且在处理重复元素时进行去重操作。具体步骤如下：

初始化空的路径path和结果集result。
创建一个辅助函数backtracking，用于回溯搜索所有可能的子集：
- 将当前路径path加入到结果集result中。
- 遍历数组nums，对每个元素进行选择和回溯：
  - 如果当前元素与前一个元素相同且前一个元素未被使用过，则跳过，以去重。
  - 将当前元素加入路径path，标记为已使用，并递归搜索下一层。
  - 回溯，将当前元素标记为未使用，移除路径中的当前元素，继续遍历其他元素。
调用主函数subsetsWithDup：
- 清空当前路径path和结果集result。
- 对输入数组nums进行排序，为了去除重复元素。
- 调用回溯函数backtracking开始搜索所有可能的子集。
- 返回最终结果集result。

代码：

class Solution {
private:
    vector<vector<int>> result; // 结果集
    vector<int> path; // 当前路径
    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
        result.push_back(path); // 将当前路径加入结果集
        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) {
        result.clear(); // 清空结果集
        path.clear(); // 清空当前路径
        vector<bool> used(nums.size(), false); // 记录元素是否被使用过
        sort(nums.begin(), nums.end()); // 先排序，去除重复元素
        backtracking(nums, 0, used); // 调用回溯函数
        return result; // 返回最终结果
    }
};

4非递减子序列

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

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

提示：

1 <= nums.length <= 15
-100 <= nums[i] <= 100

思路：

该算法使用回溯方法搜索具有相同元素的递增子序列。

回溯过程中，根据当前情况选择是否将元素加入路径中，确保元素的使用不重复，并且保证路径中的元素是递增的。

如果路径长度大于等于2，则将路径加入到结果集中。

最终返回找到的所有不重复的递增子序列。

解题的详细步骤如下：

初始化路径和结果集： 我们首先创建一个空的路径path和一个空的结果集result来存储找到的具有相同元素的递增子序列。
编写回溯函数： 我们编写一个回溯函数backtrack，用于搜索所有可能的子序列。在回溯函数中，我们需要考虑以下几点：
- 如果当前路径长度大于等于2，表示找到一个符合条件的子序列，将其加入结果集中。
- 使用一个集合used来记录已经使用过的元素，防止重复使用。
- 遍历数组nums，对每个元素进行选择和回溯：
  - 如果当前元素已经在used中，则跳过该元素，保证不重复使用。
  - 如果当前路径不为空，我们判断当前元素是否大于等于路径中的最后一个元素：
    - 如果满足条件，则选择当前元素加入路径，标记为已使用，递归搜索下一层，然后撤销选择。
    - 如果不满足条件，则跳过当前元素，寻找下一个可能的元素。
  - 如果当前路径为空，则直接选择当前元素加入路径，标记为已使用，递归搜索下一层，然后撤销选择。
调用主函数： 在主函数findSubsequences中，我们对输入数组nums进行初始化和调用回溯函数backtrack开始搜索所有符合条件的递增子序列。最后返回最终结果集result。

代码：

class Solution {
public:
    vector<int> path; // 当前路径
    vector<vector<int>> result; // 结果集
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtrack(nums, 0); // 调用回溯函数
        return result; // 返回最终结果
    }
    
    void backtrack(vector<int>& nums, int start) {
        if (path.size() >= 2) { // 如果当前路径长度大于等于2，将其加入结果集
            result.push_back(path);
        }
        
        unordered_set<int> used; // 记录已经用过的元素
        for (int i = start; i < nums.size(); i++) {
            if (used.find(nums[i]) != used.end()) { // 如果已经使用过当前元素，则跳过
                continue;
            }
            
            if (path.size() > 0) { // 如果路径不为空
                if (nums[i] >= path[path.size() - 1]) { // 当前元素大于等于路径最后一个元素
                    path.push_back(nums[i]); // 选择当前元素加入路径
                    used.insert(nums[i]); // 标记当前元素为已使用
                    backtrack(nums, i + 1); // 递归搜索下一层
                    path.pop_back(); // 撤销选择
                } else {
                    continue; // 如果当前元素小于路径最后一个元素，跳过
                }
            } else {
                path.push_back(nums[i]); // 如果路径为空，选择当前元素加入路径
                used.insert(nums[i]); // 标记当前元素为已使用
                backtrack(nums, i + 1); // 递归搜索下一层
                path.pop_back(); // 撤销选择
            }
        }
    }
};

@干吧jyb

关注

11
点赞
踩
11

收藏

觉得还不错? 一键收藏
2
评论
练习题（2024/4/27）

在递归的过程中，我们需要判断当前分割的子字符串是否合法，包括子字符串是否以0开头（除了0本身外），是否在0到255之间等。函数中，我们通过一个循环遍历所有可能的分割位置，对每个位置判断是否合法，如果合法就插入一个点并继续递归搜索下一个位置。在判断子字符串是否合法的过程中，我们需要注意首先判断是否以0开头（除了0本身外），然后再判断是否在0到255之间。回溯过程中，根据当前情况选择是否将元素加入路径中，确保元素的使用不重复，并且保证路径中的元素是递增的。，其中可能包含重复元素，请你返回该数组所有可能的。
复制链接

扫一扫