随想录二刷Day29——回溯

番茄元

已于 2024-04-03 14:56:33 修改

阅读量275

点赞数 1

文章标签：算法 leetcode

于 2024-03-25 13:30:31 首次发布

本文链接：https://blog.csdn.net/zhiai_/article/details/137011368

版权

代码随想录专栏收录该内容

81 篇文章 0 订阅

订阅专栏

文章介绍了如何使用回溯算法解决复原IP地址问题，涉及字符串处理、整数范围验证，以及在子集问题中处理重复元素的策略。通过递归实现不重复的子集查找。

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

文章目录

回溯

回溯

10 .复原IP地址

93.复原IP地址

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        if (s.length() < 4 || s.length() > 12) {
            return result;
        }
        backtracking(s, 0, 0);
        return result;
    }

private:
    vector<string> result;

    bool isVaild(string &s, int start, int end) {
        if (start > end) return false;
        // 1. 字符只能是整数
        for (int i = start; i <= end; i++) {
            if (s[i] < '0' || s[i] > '9') return false;
        }
        // 2. 数字的开头不能是 0
        if (s[start] == '0' && start != end) return false;
        // 3. 数字需要小于 255
        int num = 0;
        for (int i = start; i <= end; i++) {
            num *= 10;
            num += s[i] - '0';
        }
        std::cout << "num = " << num << std::endl;
        if (num > 255) return false;

        return true;
    }

    void backtracking(string &s, int startIndex, int cnt) {
        if (cnt == 3) {
            if (isVaild(s, startIndex, s.size() - 1)) {
                result.push_back(s);
            }
            return ;
        }

        for (int i = startIndex; i < s.size(); i++) {
            if ((i - startIndex <= 2) && isVaild(s, startIndex, i)) {
                s.insert(s.begin() + i + 1, '.');
                backtracking(s, i + 2, cnt + 1); // i+2 是因为要再往后移动一位到 ‘.’ 后面
                s.erase(s.begin() + i +  1);
            } else {
                break;
            }
        }
    }
};

11. 子集问题

78. 子集

思路：
由于题目说了没有重复的元素，所以不用考虑去重。
利用循环遍历每一层的所有元素，利用递归获取所有结果。使用一个startIndex索引指向下一个元素，保证每一次递归都不会重复访问。

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums, 0);
        return result;
    }

private:
    vector<vector<int>> result;
    vector<int> path;
    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();
        }
    }
};

12. 子集II

思路：
这次出现重复元素了，需要考虑去重问题。
根据下图可以看出，为了避免重复，还要选出所有可能的情况，同一树层不允许使用之前出现过的元素以去重，而第一次出现的有重复元素的结果会在前面的树枝中出现并被获取。从而实现不重不漏。

class Solution {
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;
    }

private:
    vector<vector<int>> result;
    vector<int> path;
    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();
        }
    }
};