代码随想录算法训练营Day28 | 93.复原IP地址 78.子集 90.子集II

代码随想录算法训练营Day28 | 93.复原IP地址 78.子集 90.子集II

LeetCode 93.复原IP地址

题目链接：LeetCode 93.复原IP地址

思路：

1. 对字符串进行操作、回溯
2. 分别判断每一段数字是否有效，如果有效，则继续，否则则break；

class Solution {
public:

    vector<string> res;
    bool isValid(string& s, int start, int end){
        if(end<start) return false;

        if(s[start] == '0' && start != end) return false;

        int num = 0;
        for(int i=start; i<=end; i++){
            if(s[i]>'9' || s[i]<'0') return false;
            num = (s[i]-'0') + 10*num;
            if (num>255) return false;
        }
        return true;
    }

    void backtracking(string& s, int index, int pointNum){
        if(pointNum==3){
            if(isValid(s, index, s.size()-1)) res.push_back(s);
            return;
        }

        for (int i=index; i<s.size(); i++){
            if(isValid(s, index, i)){
                s.insert(s.begin()+i+1, '.');
                backtracking(s, i+2, pointNum+1);
                s.erase(s.begin()+i+1);
            }
            else break;
        }
    }
    vector<string> restoreIpAddresses(string s) {
        res.clear();
        if(s.size()>12 || s.size()<4) return res;
        backtracking(s, 0, 0);
        return res;
    }
};

注意 ：

1. 对数字需进行3个判断：是否开头为0且长度大于1，是否为特殊字符， 是否大于255.

LeetCode 78.子集

题目链接：LeetCode 78.子集

思路：
遍历整棵树，所以把所有节点push入res

class Solution {
public:  

    vector<int> path;
    vector<vector<int>> res;

    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) {
        path.clear();
        res.clear();
        backtracking(nums, 0);
        return res;
    }
};

注意 ：

1. 注意要在最开始push

LeetCode 90.子集II

题目链接：LeetCode 90.子集II

思路：
与40.组合总和思路一致，利用used去重

class Solution {
public:

    vector<int> path;
    vector<vector<int>> res;

    void backtracking(vector<int>& nums, int startIndex, vector<bool>& used){
        res.push_back(path);

        for(int i=startIndex; i<nums.size(); i++){
            if(i>0 && nums[i]==nums[i-1] && used[i-1]==false) continue;
            else{
                path.push_back(nums[i]);
                used[i] = true;
                backtracking(nums, i+1, used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<bool> used(nums.size(), false);
        res.clear();
        path.clear();
        sort(nums.begin(),nums.end());
        backtracking(nums, 0, used);
        return res;
    }
};

注意 ：

1. 需要对nums进行排序不要忘记