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

Example:

Input: "25525511135"
Output: ["255.255.11.135", "255.255.111.35"]

class Solution {
public List<String> restoreIpAddresses(String s) {
        List<String> res = new ArrayList<String>();
        int len = s.length();
        StringBuffer ip = new StringBuffer();
         for (int a=1; a<=3; a++){
             for (int b=1; b<=3; b++){
                 for (int c=1; c<=3; c++){
                     int d = len - a - b - c;
                     if ( d > 0 && d <= 3 && a+b+c+d == s.length()) {
                         int A = Integer.parseInt(s.substring(0, a));
                         int B = Integer.parseInt(s.substring(a, a+b));
                         int C = Integer.parseInt(s.substring(a+b, a+b+c));
                         int D = Integer.parseInt(s.substring(a+b+c));
                         if (A<=255 && B<=255 && C<=255 && D<=255){
                             ip.append(A).append(".").append(B).append(".").append(C).append(".").append(D);
                             if( ip.length() == len + 3){
                                 res.add(ip.toString());
                             }
                             ip = new StringBuffer();
                         }
                     }   
                 }
             }
         }
        return res;
    }
}

疯狗式解法。

class Solution {
   public List<String> restoreIpAddresses(String s) {
        List<String> result = new ArrayList<>();
        doRestore(result, "", s, 0);
        return result;
    }
    
    private void doRestore(List<String> result, String path, String s, int k) {
        if (s.isEmpty() || k == 4) {
            if (s.isEmpty() && k == 4)
                result.add(path.substring(1));
            return;
        }
        for (int i = 1; i <= (s.charAt(0) == '0' ? 1 : 3) && i <= s.length(); i++) { // Avoid leading 0
            String part = s.substring(0, i);
            if (Integer.valueOf(part) <= 255)
                doRestore(result, path + "." + part, s.substring(i), k + 1);
        }
    }
}

注意ip地址并不能以0开头比如01.01.01.01，只能由1个0开头

public List<String> restoreIpAddresses(String s) {
    List<String> ans = new ArrayList<>(); //保存最终的所有结果
    getAns(s, 0, new StringBuilder(), ans, 0);
    return ans;
}

/**
* @param:  start 字符串开始部分
* @param:  temp 已经划分的部分
* @param:  ans 保存所有的解
* @param:  count 当前已经加入了几部分
*/
private void getAns(String s, int start, StringBuilder temp, List<String> ans, int count) {
    //如果剩余的长度大于剩下的部分都取 3 位数的长度，那么直接结束
    //例如 s = 121231312312, length = 12
    //当前 start = 1，count 等于 1
    //剩余字符串长度 11，剩余部分 4 - count = 3 部分，最多 3 * 3 是 9
    //所以一定是非法的，直接结束
    if (s.length() - start > 3 * (4 - count)) {
        return;
    }
    //当前刚好到达了末尾
    if (start == s.length()) {
        //当前刚好是 4 部分，将结果加入
        if (count == 4) {
            ans.add(new String(temp.substring(0, temp.length() - 1)));
        }
        return;
    }
    //当前超过末位，或者已经到达了 4 部分结束掉
    if (start > s.length() || count == 4) {
        return;
    }
    //保存的当前的解
    StringBuilder before = new StringBuilder(temp);

    //加入 1 位数
    temp.append(s.charAt(start) + "" + '.');
    getAns(s, start + 1, temp, ans, count + 1);

    //如果开头是 0，直接结束
    if (s.charAt(start) == '0')
        return;

    //加入 2 位数
    if (start + 1 < s.length()) {
        temp = new StringBuilder(before);//恢复为之前的解
        temp.append(s.substring(start, start + 2) + "" + '.');
        getAns(s, start + 2, temp, ans, count + 1);
    }

    //加入 3 位数
    if (start + 2 < s.length()) {
        temp = new StringBuilder(before);
        int num = Integer.parseInt(s.substring(start, start + 3));
        if (num >= 0 && num <= 255) {
            temp.append(s.substring(start, start + 3) + "" + '.');
            getAns(s, start + 3, temp, ans, count + 1);
        }
    }

}