LeetCode题练习与总结：复原IP地址--93

一、题目描述

有效 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 地址。

给定一个只包含数字的字符串 s ，用以表示一个 IP 地址，返回所有可能的有效 IP 地址，这些地址可以通过在 s 中插入 '.' 来形成。你 不能 重新排序或删除 s 中的任何数字。你可以按 任何 顺序返回答案。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 1 <= s.length <= 20
• s 仅由数字组成

二、解题思路

这个问题是一个典型的回溯问题，我们可以使用递归的方式来解决。首先，我们需要明确几个规则：

1. IP 地址由四部分组成，每部分的范围在 0 到 255 之间。
2. 每部分可以是 1 到 3 位数字。
3. 不能有前导 0，即 0 不能出现在除了单个 0 自身以外的其他数字的开头。

基于以上规则，我们可以按照以下步骤来解决这个问题：

1. 初始化一个列表 result 来保存所有可能的 IP 地址。
2. 定义一个递归函数 restoreIpAddressesHelper，该函数接受当前构建的 IP 地址 currentIp，剩余未处理的字符串 remaining，以及当前已添加的段数 segment。
3. 在递归函数中，如果 segment 等于 4 且 remaining 为空，说明一个有效的 IP 地址构建完成，将其添加到 result 列表中。
4. 遍历 remaining 字符串，对于每个位置，尝试提取 1 到 3 位数字作为 IP 地址的一部分，并递归调用 restoreIpAddressesHelper。
5. 在递归调用之前，检查提取的数字是否在 0 到 255 的范围内，且没有前导 0（除了数字 0 本身）。
6. 最后，返回 result 列表。

三、具体代码

import java.util.ArrayList;
import java.util.List;

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

    private void restoreIpAddressesHelper(List<String> result, String currentIp, String remaining, int segment) {
        if (segment == 4 && remaining.isEmpty()) {
            result.add(currentIp);
            return;
        }

        for (int i = 1; i <= 3 && i <= remaining.length(); i++) {
            String part = remaining.substring(0, i);
            if ((part.startsWith("0") && part.length() > 1) || Integer.parseInt(part) > 255) {
                continue;
            }
            restoreIpAddressesHelper(result, currentIp.isEmpty() ? part : currentIp + "." + part, remaining.substring(i), segment + 1);
        }
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        List<String> ipAddresses = solution.restoreIpAddresses("25525511135");
        System.out.println(ipAddresses);
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 最坏情况分析：对于 IP 地址的每个部分，我们有三种选择：取一位、取两位或取三位数字。因此，对于四个部分，最坏情况下的时间复杂度是 O(3^4)。

• 实际分析：然而，由于输入字符串 s 的长度限制（1 <= s.length <= 20），我们通常不会探索所有可能的选择。例如，如果剩余的字符串长度不足以构成四个有效的 IP 地址部分，我们会提前停止递归。这意味着实际的时间复杂度会低于 O(3^4)。

• 递归调用次数：递归调用的次数取决于输入字符串的长度和字符串中数字的分布。在最坏情况下，每次递归调用会有三次新的递归调用，但这通常会被输入字符串的长度限制所减少。

• 综上所述，时间复杂度是 O(3^4)，但通常会低于这个值。

2. 空间复杂度

• 递归栈空间：递归栈的最大深度是 4，因为 IP 地址有四部分。因此，递归栈的空间复杂度是 O(4)。

• 结果存储空间：结果列表 result 的大小取决于输入字符串 s 可以形成的有效 IP 地址的数量。在最坏情况下，这个数量是 O(3^4)。然而，实际上，由于输入字符串的长度限制，生成的有效 IP 地址数量通常会远小于这个上界。

• 实际空间复杂度：由于实际的 IP 地址数量通常远小于 O(3^4)，实际的空间复杂度通常会低于这个值。

• 综上所述，空间复杂度是 O(3^4)，但通常会低于这个值。

五、总结知识点

1. 回溯算法：这是一种通过探索所有可能的候选解来找到所有解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会丢弃该解，即回溯并且尝试另一个候选解。

2. 递归：这是一种编程技巧，函数自己调用自己。在这个问题中，restoreIpAddressesHelper 函数递归地调用自己来探索所有可能的 IP 地址组合。

3. 字符串操作：代码中使用了字符串的 substring 方法来提取字符串的一部分，以及 isEmpty 和 startsWith 方法来检查字符串是否为空或者是否以某个特定字符开头。

4. 整数转换：使用了 Integer.parseInt 方法将字符串转换为整数。这在检查提取的字符串是否在 0 到 255 的范围内时使用。

5. 列表（List）：使用了 ArrayList 来存储找到的所有可能的 IP 地址。ArrayList 是 Java 中 List 接口的一个实现，它允许我们动态地添加、删除和访问元素。

6. 条件语句：使用了 if 语句来检查递归的基本情况（当生成了一个完整的 IP 地址时）以及提取的字符串部分是否有效。

7. 循环：使用了 for 循环来遍历所有可能的字符串部分长度（1 到 3）。

8. 函数定义和调用：定义了 restoreIpAddresses 和 restoreIpAddressesHelper 两个函数，并在 restoreIpAddresses 函数中调用了 restoreIpAddressesHelper。

9. 参数传递：在递归调用中，通过参数传递当前的 IP 地址部分、剩余的字符串和当前段数。

10. 递归的基本情况：在 restoreIpAddressesHelper 函数中，当生成了一个完整的 IP 地址时（段数为 4 且没有剩余的字符串），将其添加到结果列表中，这是递归的基本情况。

11. 递归的递推关系：在 restoreIpAddressesHelper 函数中，通过递归调用自己来处理下一个 IP 地址段，这是递归的递推关系。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。