93. 复原 IP 地址

leetcode题目地址

题目有一个很重要的要求：你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。 也就是说ip地址中需要包含整个字符串中的字符且顺序不可变。

ip地址的每一个数字都需要在[0, 255]范围内，所以其截取的长度就是1-3。

回溯终止条件“：使用一个数组cur记录当前ip中的数字，若当前已有四个数字且字符串内的数字均包含在内，则将cur中存储的数字拼成一个ip放入结果数组中并返回。

回溯：从起始位置开始截取子串并判断当前子串组成的数字是否是在[0, 255]区间内，若是则继续查找后面位置的子串。 这里有一个小trick就是组成[0, 255]的数字的长度是[1, 3]，所以最长截取位置就是起始位置后三位的位置，也就是left+3。

（另一种思路）

时间复杂度： $O(3^4)$
空间复杂度： $O(n)$

// c++
class Solution {
public:
    vector<string> cur;
    bool isValid(const string& s, int left, int right){
        // 非0元素有前导0
        if(right>left && s[left]=='0') return false;
        int res = 0;
        for(int i=left; i<=right; i++){
            res = res*10 + s[i]-'0';
        }
        if(res>=0 && res<=255 ) return true;
        return false;
    }

    void backtracking(vector<string> & result, const string &s, int left){
        
        if(cur.size() == 4 && left>=s.size()){
            string str = "";
            for(int i=0; i<cur.size(); i++){
                if(i>0) str += ".";
                str += cur[i];
            }
            result.emplace_back(str);
            return;
        }
        // 这行代码可有可无 因为起始下标超过数组长度就不会进入下面的循环
        if(left>=s.size()) return;
        // 截取子串 长度区间为[1, 3]
        for(int i=left; i<s.size() && i<left+3; i++){
            if(isValid(s, left, i)){
                string str = s.substr(left, i-left+1);
                cur.emplace_back(str);
                backtracking(result, s, i+1);
                cur.pop_back();
            }
        }
    }

    vector<string> restoreIpAddresses(string s) {
        vector<string> result;
        backtracking(result, s, 0);
        return result;
    }
};

78. 子集

leetcode题目地址

这一题比较简单，从起始位置遍历，将其每一次的结果都放入最终结果中既可。需要在最初将空集放入最终结果数组中。

时间复杂度： $O(n\ast 2^n)$
空间复杂度： $O(n)$

// c++
class Solution {
public:
    vector<int> cur;
    void backtracking(vector<vector<int>> & result, const vector<int>& nums, int left){
        // 这一行可有可无  因为起始下标查过数组长度不会进入下边循环
        if(left>nums.size()) return;
        for(int i=left; i<nums.size(); i++){
            cur.emplace_back(nums[i]);
            result.emplace_back(cur);
            backtracking(result, nums, i+1);
            cur.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> result;
        result.emplace_back(cur);
        backtracking(result, nums, 0);
        return result;

    }
};

90. 子集 II

leetcode题目地址

在上一题的基础上加一步去重即可。去重需要判断元素与前一个元素是否相同，因此先对nums进行排序，使其相同元素相邻。

去重做法和40. 组合总和 II相同（题解）。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
class Solution {
public:
    vector<int> cur;
    void backtracking(vector<vector<int>> & result, const vector<int>& nums, int left){
        // 这一行可有可无  因为起始下标查过数组长度不会进入下边循环
        if(left>nums.size()) return;
        for(int i=left; i<nums.size(); i++){
			// 去重
            if(i>left && nums[i]==nums[i-1]) continue;
            cur.emplace_back(nums[i]);
            result.emplace_back(cur);
            
            backtracking(result, nums, i+1);
            cur.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        vector<vector<int>> result;
        // 排序
        result.emplace_back(cur);
        sort(nums.begin(), nums.end());
        backtracking(result, nums, 0);
        return result;
    }
};