算法 ： 字符串转化成IP地址 【回溯（Backtracking）问题】

牛客网

题目

现在有一个只包含数字的字符串，将该字符串转化成IP地址的形式，返回所有可能的情况。
例如：
给出的字符串为"25525522135",
返回["255.255.22.135", "255.255.221.35"]. (顺序没有关系)

数据范围：字符串长度 0≤n≤120≤n≤12
要求：空间复杂度 O(n!)O(n!),时间复杂度 O(n!)O(n!)

注意：ip地址是由四段数字组成的数字序列，格式如 "x.x.x.x"，其中 x 的范围应当是 [0,255]。 

解析

这是一个经典的 回溯（Backtracking） 问题，要求将一个数字字符串转化为所有可能的合法 IP 地址形式。

✅ 题意解析

• 给定一个只包含数字的字符串 s。
• 要求返回所有可能的 IP 地址格式，每段在 [0, 255] 范围内。
• 每个 IP 地址由四段组成，用点分隔：x.x.x.x
• 不允许前导零，除非是单个 0（如 "01" 或 "00" 是非法的，但 "0" 是合法的）

✅ 解题思路：回溯法（DFS）

步骤：

1. 在字符串中插入三个点，把字符串分成四段。
2. 检查每一段是否满足 IP 地址的规则：
   • 长度为 1~3
   • 数值在 0~255 之间
   • 不能有前导 0（除非就是 “0”）
3. 收集所有合法组合作为结果。

✅ Java 实现

import java.util.*;

public class Solution {
    public ArrayList<String> restoreIpAddresses(String s) {
        ArrayList<String> result = new ArrayList<>();
        int n = s.length();

        if (n < 4 || n > 12) return result; // 特判不可能情况

        for (int i = 1; i <= 3 && i < n - 2; i++) {
            for (int j = i + 1; j <= i + 3 && j < n - 1; j++) {
                for (int k = j + 1; k <= j + 3 && k < n; k++) {
                    String seg1 = s.substring(0, i);
                    String seg2 = s.substring(i, j);
                    String seg3 = s.substring(j, k);
                    String seg4 = s.substring(k, n);

                    if (isValid(seg1) && isValid(seg2) && isValid(seg3) && isValid(seg4)) {
                        result.add(seg1 + "." + seg2 + "." + seg3 + "." + seg4);
                    }
                }
            }
        }

        return result;
    }

    private boolean isValid(String segment) {
        if (segment.length() > 3 || segment.isEmpty()) return false;
        if (segment.length() > 1 && segment.charAt(0) == '0') return false; // 前导0
        if (Integer.parseInt(segment) > 255) return false;
        return true;
    }
}

✅ 时间与空间复杂度分析

• 时间复杂度：O(n!)
  • 最坏情况下要枚举所有可能的分割方式，数量级接近排列组合的数量级。
• 空间复杂度：O(n!)
  • 所有可能的 IP 地址都会被保存到结果列表中。

✅ 示例

输入：

"25525522135"

输出：

["255.255.22.135", "255.255.221.35"]

🧠 小贴士

• 可以使用 DFS/回溯递归方式实现，逻辑更清晰。
• 如果想支持大数范围判断，可以使用 Integer.valueOf(segment) 来避免溢出。
• 对于无效输入，比如长度小于 4 或大于 12，可以直接剪枝优化。

如果你希望我提供递归版本或进一步优化（例如剪枝），也可以告诉我。