93. 复原IP地址

93. 复原IP地址

题目描述

给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。

有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 '.' 分隔。

例如：“0.1.2.201” 和 “192.168.1.1” 是 有效的 IP 地址，但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效的 IP 地址。

示例 1：

输入：s = "25525511135"
输出：["255.255.11.135","255.255.111.35"]

示例 2：

输入：s = "0000"
输出：["0.0.0.0"]

示例 3：

输入：s = "1111"
输出：["1.1.1.1"]

示例 4：

输入：s = "010010"
输出：["0.10.0.10","0.100.1.0"]

示例 5：

输入：s = "101023"
输出：["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

提示：

• $0\le s.length\le 3000$
• s 仅由数字组成

---

题解：

法一：

回溯。

一个 IP 有四个数字，直接枚举每个数字就好。但是，这里的 0 需要处理一下，0 只能单独存在，而 0xxx 是不合法的。在枚举新的一位数时，如果第一位为 0 就要停止。

有一些剪枝技巧，假设还剩 n 个数字待确定：

1. 如果每个数字都是 3 位数的话，当 n * 3 小于剩下未枚举的字符串长度时，直接返回即可。

2. 如果 n 大于剩余字符串的长度，直接返回即可。

时间复杂度：$O(3^4\ast n)=O(n)$

额外空间复杂度：$O(4)=O(1)$

class Solution {
public:
    vector<string> ret;
    vector<int> ip;
    void dfs( int p, int num, const string& s ) {
        if ( (4 - num) * 3 < s.size() - p ) return;
        if ( (4 - num) > s.size() - p ) return;
        if ( p >= s.size() ) {
            if ( num == 4 ) {
                string ans = to_string( ip[0] );
                for ( int i = 1; i < 4; ++i )
                    ans += '.' + to_string( ip[i] );
                ret.emplace_back( ans );
            }
            return;
        }
        if ( num > 4 ) return;
        int val = 0;
        for ( int i = p; i < s.size(); ++i ) {
            val = val * 10 + (s[i] & 15);
            if ( val < 256 ) {
                ip.emplace_back( val );
                dfs( i + 1, num + 1, s );
                ip.pop_back();
                if ( !val ) break;
            } else break;
        }
    }
    vector<string> restoreIpAddresses(string s) {
        dfs( 0, 0, s );
        return ret;
    }
};
/*
时间：0ms，击败：100.00%
内存：6.4MB，击败：98.38%
*/

法二：

四重循环暴力。

class Solution {
public:
    bool check( const string& s ) {
        int num = stoi(s);
        if ( num > 0xFF ) return false;
        return ( s[0] != '0' || s[0] == '0' && s.size() == 1 );
    }
    vector<string> restoreIpAddresses(string s) {
        vector<string> ret;
        if ( s.size() < 4 || s.size() > 12 ) return ret;
        string s1, s2, s3, s4, ans;
        for ( int a = 1; a < 4; ++a ) {
            for ( int b = 1; b < 4; ++b ) {
                if ( a + b > s.size() ) break;
                for ( int c = 1; c < 4; ++c ) {
                    if ( a + b + c > s.size() ) break;
                    for ( int d = 1; d < 4; ++d ) {
                        if ( a + b + c + d > s.size() ) break;
                        if ( a + b + c + d < s.size() ) continue;
                        s1 = s.substr( 0, a );
                        s2 = s.substr( a, b );
                        s3 = s.substr( a + b, c );
                        s4 = s.substr( a + b + c, d );
                        if ( !check(s1) || !check(s2) || !check(s3) || !check(s4) ) continue;
                        ans = s1 + '.' + s2 + '.' + s3 + '.' + s4;
                        ret.emplace_back( ans );
                    }
                }
            }
        }
        return ret;
    }
};
/*
时间：0ms，击败：100.00%
内存：6.5MB，击败：94.89%
*/