93. 复原 IP 地址

原题链接：
完成情况：
解题思路：
- - [Key Components and Logic](#Key Components and Logic)
  - [Detailed Breakdown](#Detailed Breakdown)
  - - [Main Method](#Main Method)
    - [DFS Method](#DFS Method)
  - [Key Points](#Key Points)
参考代码：
- _93复原IP地址_回溯
错误经验吸取

原题链接：

https://leetcode.cn/problems/restore-ip-addresses/description/

完成情况：

解题思路：

This Java solution is designed to generate all possible valid IP addresses from a given string s. The code utilizes a depth-first search (DFS) strategy to explore all potential segmentations of the input string into four parts, each representing an octet of an IP address. Let's break down the implementation and the key components of this solution.

Key Components and Logic

Class Members:
- List<String> result: A list to store the resulting valid IP addresses.
- static final int SEGCOUNT = 4: A constant to represent the number of segments in an IP address.
- int[] SEGMENTS = new int[SEGCOUNT]: An array to store the current segments of the IP address being formed.
Main Method (restoreIpAddresses):
- Takes the input string s.
- Initiates the DFS with the starting segment number (segNums = 0) and starting index (segIndex = 0).
- Returns the list of valid IP addresses.
DFS Method (dfs_restoreIpAddresses):
- Base Case: If the number of segments equals SEGCOUNT and the end of the string is reached, it forms a valid IP address.
- Edge Case: If the end of the string is reached before forming 4 segments, it returns early.
- Handling Leading Zeroes: If a segment starts with '0', only '0' is considered as a valid segment.
- General Case: It forms segments by considering each substring from the current index to the next positions, ensuring each segment is within the valid range (0-255).

Detailed Breakdown

Main Method

java 复制代码

public List<String> restoreIpAddresses(String s) {
    dfs_restoreIpAddresses(s, 0, 0);
    return result;
}

Calls the dfs_restoreIpAddresses method to start the DFS traversal.
Returns the result list containing all valid IP addresses.

DFS Method

java 复制代码

private void dfs_restoreIpAddresses(String s, int segNums, int segIndex) {
    // Base case: If four segments are formed
    if (segNums == SEGCOUNT) {
        if (segIndex == s.length()) {
            StringBuilder ipAddress = new StringBuilder();
            for (int i = 0; i < SEGCOUNT; ++i) {
                ipAddress.append(SEGMENTS[i]);
                if (i < SEGCOUNT - 1) {
                    ipAddress.append('.');
                }
            }
            result.add(ipAddress.toString());
        }
        return;
    }
    
    // Edge case: If the string is exhausted before forming 4 segments
    if (segIndex == s.length()) {
        return;
    }

    // Handling leading zeroes
    if (s.charAt(segIndex) == '0') {
        SEGMENTS[segNums] = 0;
        dfs_restoreIpAddresses(s, segNums + 1, segIndex + 1);
        return;
    }

    // Form segments and proceed with DFS
    int addr = 0;
    for (int segNext = segIndex; segNext < s.length(); segNext++) {
        addr = addr * 10 + (s.charAt(segNext) - '0');
        if (addr > 0 && addr <= 255) {
            SEGMENTS[segNums] = addr;
            dfs_restoreIpAddresses(s, segNums + 1, segNext + 1);
        } else {
            return;
        }
    }
}

Key Points

Base Case Handling: Ensures that exactly 4 segments are formed and the entire string is consumed.
Leading Zeroes: Special case handling where '0' can only be a segment by itself.
Valid Range Check: Each potential segment is validated to be within the range $0, 255$ .
DFS Traversal: Recursively explores all possible segmentations by adjusting segment numbers and string indices.

This algorithm ensures that all valid combinations are checked systematically and invalid cases are pruned early, leading to efficient generation of valid IP addresses from the given string.

参考代码：