leetcode刷题

ip地址

（太复杂了）

vector<string> result;
  
    void backing(string &s, int startindex, int dot){
        if(startindex >= s.size())
            return ;
        if(dot == 3 && startindex + 3 >= s.size() && 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, '.');
                backing(s, i + 2, dot + 1);
                s.erase(s.begin() + i + 1);
            }
            else
                break;
        }
        return ;
            
    }
    bool isvalid(string &s, int start, int end){
        string str = s.substr(start, end - start + 1);
        if(str.size() > 3)
            return false;
        if(str.size() > 1 && str[0] == '0'){
            return false;
        }
        int k = stoi(str);
        if(k > 255){
            return false;
        }
        return true;
    }
    vector<string> restoreIpAddresses(string s) {
        
        backing(s, 0, 0);
        return result;
    }

子集

使用模板，之前的模板是只收集叶子节点，该题目就是收集这个路程中所有的节点。

    vector<vector<int>> result;
    vector<int> path;
    void backing(vector<int>& nums, int k, int startindex){
        if(path.size() == k){
            result.push_back(path);
            return;
        }
            
        for(int i = startindex; i < nums.size(); i++){
            path.push_back(nums[i]);
            backing(nums, k, i + 1);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        for(int i = 1; i <= nums.size(); i++){
            backing(nums, i, 0);
        }
        result.push_back(path);
        return result;
    }

//换种写法   秒啊
    vector<vector<int>> result;
    vector<int> path;
    void backing(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]);
            backing(nums, i + 1);
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        
        backing(nums, 0);
        return result;
    }

子集II

是之前组合II去重，和子集的结合体

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