算法---LeetCode 93. 复原 IP 地址

1. 题目

原题链接

给定一个只包含数字的字符串，用以表示一个 IP 地址，返回所有可能从 s 获得的 有效 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”]

2. 题解

2.1 解法1: DFS回溯

递归函数

参数: pathList 当前保存的子串同时其长度也代表了当前递归的深度, start 当前遍历的起点, 即下一个开始切割的位置
作用: 找到从 start 到末尾的子串。
约束(剪枝)条件: 1.开启下一层递归时, start不能超界 2.一个片段的长度是 1~3 3.片段的值范围是 0~255 3.不能是 “0x”、“0xx” 形式（测试用例告诉我们的）
目标(终止条件): 1.pathList 长度大于4, 结束递归 2.生成了四个有效子串且start为原串末尾

    class Solution {
        public List<String> restoreIpAddresses(String s) {
            List<String> ans = new ArrayList<>();
            dfs(new ArrayList<>(), 0, s, ans);
            return ans;
        }

        public void dfs(List<String> pathList, int start, String s, List<String> ans) {
            // 子串片段满4段，且耗尽所有字符,  拼成字符串，加入解集
            if (pathList.size() > 4) return;
            if (pathList.size() == 4 && start == s.length()) {
                ans.add(String.join(".", pathList));// join 用法：例如 [[255],[255],[111],[35]] -> 255.255.111.35
                return;
            }
            for (int len = 1; len <= 3; len++) {
                // 约束条件排除
                if (start + len > s.length()) return;
                if (len != 1 && s.charAt(start) == '0') return;
                String str = s.substring(start, start + len);
                if (Integer.parseInt(str) > 255) return;
                pathList.add(str);
                dfs(pathList, start + len, s, ans);
                pathList.remove(pathList.size() - 1);
            }
        }
    }

参考:
『手画图解』DFS回溯中的细节 | 93. 复原IP地址

2.2 解法2: 暴力解法(四重for)

    class Solution {
        public List<String> restoreIpAddresses(String s) {
            List<String> ans = new ArrayList<>();
            StringBuilder ip = new StringBuilder();
            for (int a = 1; a < 4; ++a)
                for (int b = 1; b < 4; ++b)
                    for (int c = 1; c < 4; ++c)
                        for (int d = 1; d < 4; ++d) {
                            if (a + b + c + d == s.length()) {
                                int n1 = Integer.parseInt(s.substring(0, a));
                                int n2 = Integer.parseInt(s.substring(a, a + b));
                                int n3 = Integer.parseInt(s.substring(a + b, a + b + c));
                                int n4 = Integer.parseInt(s.substring(a + b + c));
                                if (n1 <= 255 && n2 <= 255 && n3 <= 255 && n4 <= 255) {
                                    ip.append(n1).append('.').append(n2).append('.').append(n3).append('.').append(n4);
                                    if (ip.length() == s.length() + 3) ans.add(ip.toString());
                                    ip.delete(0, ip.length());
                                }
                            }
                        }
            return ans;
        }
    }

参考: 可能是最优美的暴力解法了