【代码随想录】day28

最新推荐文章于 2024-07-24 22:13:06 发布

weixin_47041555

最新推荐文章于 2024-07-24 22:13:06 发布

阅读量134

点赞数 1

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

本文链接：https://blog.csdn.net/weixin_47041555/article/details/137039026

版权

文章介绍了两个与回溯算法相关的编程问题：如何恢复一个有效的IP地址表示和处理包含重复数字的整数子集。Solution类中定义了backtracking函数，用于递归地探索所有可能的解决方案。

摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、93复原IP地址

class Solution {
public:
    vector<string> res;
    string path;
    bool isValid(string s) {
        if (s.size() > 1 && s[0] == '0') {
            return false;
        }
        return stoi(s) <= 255;
    }

    void backtracking(string s, int count, int startIndex) {
        if (count == 4 && startIndex == s.size()) {
            path.pop_back();
            res.push_back(path);
        }
        if (count >= 4 || startIndex >= s.size()) {
            return;
        }
        for (int len = 1; len <= 3; len ++) {
            string temp = s.substr(startIndex, len);
            if (isValid(temp) == false) {
                continue;
            }
            path += temp;
            path += ".";
            backtracking(s, count + 1, startIndex + len);
            path = path.substr(0, startIndex + count);
        }
    }

    vector<string> restoreIpAddresses(string s) {
        backtracking(s, 0, 0);
        return res;
    }
};

二、78子集

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    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();
        }
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums, 0);
        return res;
    }
};

backtracking()里的终止条件不写也可以，因为循环在startIndex>=nums.size()时会终止。

三、90子集II

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    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 (path.size() == 0 && i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            if (i > startIndex && nums[i] == nums[i-1]) {
                continue;
            }
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return res;
    }
};