Leetcode: Restore IP Addresses

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

For example:
Given "25525511135",

return ["255.255.11.135", "255.255.111.35"]. (Order does not matter)

一开始想复杂了，还以为要用DP之类的。其实呢最长12个字符，超过了就表明无效的IP地址。不过要注意处理”000“这种无效情况。

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        string ip;
        int counts = 0;
        int size = s.size();
        if (size <= 12 && size >= 4) {
            validIpAddress(s, 0, ip, counts);
        }
        
        return result;
    }
    
    void validIpAddress(string &s, int start, string &ip, int counts) {
        if (start == s.size()) {
            if (counts == 4) {
                ip.pop_back();
                result.push_back(ip);
            }
            return;
        }
        else if (counts >= 4) {
            return;
        }
        
        int sum = 0;
        for (int j = 0; j < 3 && start + j < s.size(); ++j) {
            sum = sum * 10 + (s[start+j] - '0');
            if (sum >= 0 && sum <= 255) {
                int pos = ip.size();
                ip.append(s.substr(start, j + 1));
                ip.push_back('.');
                validIpAddress(s, start + j + 1, ip, counts + 1);
                ip.erase(pos);
            }
            
            // "00"/"01" is invalid ip segment
            if (s[start] == '0') {
                break;
            }
        }
    }

private:
    vector<string> result;
};

============第二次=============

合法的结果要理解沟通清楚，边界条件要仔细，咋不长记性呢。。。

class Solution {
public:
    vector<string> restoreIpAddresses(string s) {
        vector<string> result;
        size_t size = s.size();
        if (size < 4 || size > 12) {
            return result;
        }
        
        string candidate;
        restore(result, candidate, s, 0, 0);
        
        return result;
    }
    
    void restore(vector<string> &result, string candidate, const string &s, size_t start, int segs) {
        if (start == s.size() && segs == 4) {
            result.push_back(candidate);
            return;
        }
        
        int remains = s.size() - start;
        if (remains < 4 - segs || remains > (4 - segs) * 3) {
            return;
        }
        
        if (segs > 0) {
            candidate.push_back('.');
        }
        int address = 0;
        for (int i = 0; i < 3 && start + i < s.size(); ++i) {
            address = address * 10 + s[start+i] - '0';
            if (address < 256) {
                restore(result, candidate + s.substr(start, i+1), s, start+i+1, segs+1);
            }
            if (address == 0) {
                break;
            }
        }
    }
};