93. 复原 IP 地址

题目

解法

1. 暴力破解，自己初始想法加上看完题解中思想的修补

class Solution {
private:
    vector<string> result;
    string path;
    int num = 0;
    void backtracking(string s, int startIdx) {
        if(startIdx >= s.size() && num == 4) { //终止条件
            result.push_back(path);
            return ;
        }
        if (num > 4) return; // 终止条件
        for (int i = startIdx; i < s.size(); i++) {
            string str = s.substr(startIdx, i - startIdx + 1);
            if (isTrue(str)) {
                if(!path.empty()) path += '.';
                path += str;  
                num += 1;
            } else {
                continue ;
            }
            backtracking(s, i+1);
            int fenge = 0; // 为了刚才移动进来的str
            for(int j = path.size(); j >= 0; j--) {
                if(path[j] == '.') {
                    fenge = j;
                    break;
                }
            }
            if(fenge > 0) {
                path = path.substr(0, fenge); // 回溯
            }else {
                path.clear();
            }  
            num -= 1;
        }
        return ;
    }
    bool isTrue(string str) {
        if (stod(str) < 0 || stod(str) >255) return false;
        
        if(str[0] == '0' && str.size() > 1) return false;
      
        return true;
    }

public:
    
    vector<string> restoreIpAddresses(string s) {
        result.clear();
        path.clear();
        backtracking(s, 0);
        return result;
    }
};

2.使用指针，空间利用率提高，删除很多没必要的循环，时间利用率提高

class Solution {
private:
    vector<string> result;
    // 在合适的位置插入点号就ok
    void backtracking(string& s, int startIdx, int pointNum) {
        // 终止条件
        if (pointNum == 3) {
            if(isValid(s, startIdx, s.size()-1)){
                result.push_back(s);
            }
            return;
        }
        // 单层逻辑
        for (int i = startIdx ; i < s.size() ; i++) {
            if(isValid(s, startIdx, i)){ // 判断 [startIdx, i ]是否符合要求
                s.insert(s.begin() + i + 1, '.');
                pointNum++;
                backtracking(s, i + 2, pointNum );
                pointNum--;
                s.erase(s.begin() + i + 1);// 删除点号
            }else break; // 数字多了，之后肯定就不符合
            
        }
        return ;

    }
    bool isValid(string s, int start, int end){
        if(start > end) return false; // 没有数值

        if(s[start] == '0' && start != end) return false; // 前导有0
        int num = 0;
        for(int i = start; i <= end; i++) {
            if(s[i] > '9' || s[i] < '0') return false; // 出现非数字元素
            num = num*10 + s[i] - '0';
            if(num > 255) return false; // 超过最大数值
        }
        return true;
    }
        

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

78. 子集

题目

解法

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int> nums, int startIdx) {
        result.push_back(path); // 是取所有节点，之前是取叶子节点
        if(startIdx >= nums.size()){ // 
            return;
        }
        for (int i = startIdx; i < nums.size(); i++) {
            path.push_back(nums[i]);
            backtracking(nums, i + 1);
            path.pop_back();
        }
        return ;
    }

public:
    vector<vector<int>> subsets(vector<int>& nums) {
        result.clear();
        path.clear();
        backtracking(nums,0);
        return result;
    }
};

90. 子集 II

题目

解法

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int> nums, int startIdx, vector<bool> used) {
        result.push_back(path); // 是取所有节点，之前是取叶子节点
        if(startIdx >= nums.size()){ // 
            return;
        }
        for (int i = startIdx; 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();
        }
        return ;
    }
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;
    }
};

感悟

大道至简，代码写的越繁杂，说明对问题理解和把握越不够透彻。