代码随想录刷题第28天

第一题是复原ip地址https://leetcode.cn/problems/restore-ip-addresses/description/，与上一题分割回文串类似，都是利用start index进行切割。这道题具体细节也很多，代码自己打一遍才感受的出来。

class Solution {
public:
    vector<string> result;
    void backtracking(string& s, int startindex, int pointNum){
        if (pointNum == 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, '.');
                pointNum++;
                backtracking(s, i + 2, pointNum);//从逗点后开始递归
                pointNum--;
                s.erase(s.begin() + i + 1);
            }
            else break;
        }
    }
    bool isValid(const string& s, int start, int end){//判断合法性
    if (start > end) return false;
    if (s[start] == '0' && start != end) return false;
    int sum = 0;
    for (int i = start; i <= end; i++){
        if (s[i] > '9' || s[i] < '0') return false;
        sum = sum * 10 + s[i] - '0';
        if (sum > 255) return false;
    }
    return true;
    }
    vector<string> restoreIpAddresses(string s) {
     backtracking(s, 0, 0);
     return result;
    }
};

第二题是子集https://leetcode.cn/problems/subsets/，收集整数数组中所有的子集。子集问题与组合问题的不同之处在于树中每个结点都需要收集，即每层递归的结果都要加入result中。

class Solution {
public:
vector<int> path;
vector<vector<int>> result;
    void backtracking(vector<int>& nums, int startindex){
    result.push_back(path);//每层递归的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;
    }
};

第三题是子集IIhttps://leetcode.cn/problems/subsets-ii/description/，是上题的进阶，不过要注意去重操作，做起来不难，一遍代码就ac了。

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

越做越顺了，加油。