代码随想录算法训练营第二十八天回溯法

最新推荐文章于 2024-09-05 20:52:23 发布

妮可小夫

最新推荐文章于 2024-09-05 20:52:23 发布

阅读量50

点赞数

文章标签：算法 leetcode c++

本文链接：https://blog.csdn.net/m0_64144465/article/details/129804597

版权

93.复原IP地址

class Solution {
public:
    vector<string> result;
    string path;
    bool isValid(string s, int left, int right) {
        if (left > right) return false;
        if (right - left > 2) return false;
        int sum = 0;
        for (int i = left; i <= right; ++i) {
            if (s[i] - '0' > 9 || s[i] - '0' < 0) {
                return false;
            }
            if (i == left && s[i] == '0' && right - left >= 1) {
                return false;
            }
            sum = sum * 10 + (s[i] - '0');
        }
        if (sum > 255) return false;
        return true;
    }
    void backtracking(string s, int startindex, int pointsum) {
        if (pointsum == 3) {
            if (isValid(s, startindex, s.size() - 1)) {
                result.push_back(path);
            }
            return;
        }
        for (int i = startindex; i < s.size(); ++i) {
            if (isValid(s, startindex, i)) {
                pointsum++;
                path.insert(path.begin() + i + pointsum, '.');
                backtracking(s, i + 1, pointsum);
                path.erase(path.begin() + i + pointsum);
                pointsum--;
            } else break;
        }
    }
    vector<string> restoreIpAddresses(string s) {
        if (s.size() < 4 && s.size() > 12) return result; 
        result.clear();
        path = s;
        backtracking(s, 0, 0);
        return result;
    }
};

78. 子集

class Solution {
public:
    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();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        backtracking(nums, 0);
        return result;
    }
};

90. 子集 II

class Solution {
public:
    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 >= 1 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        int len = nums.size();
        vector<bool> used(len, false); 
        sort(nums.begin(), nums.end());
        backtracking(nums, 0, used);
        return result;
    }
};