Restore IP Addresses

Restore IP Addresses - Problem

String Backtracking Medium

A valid IP address consists of exactly four integers separated by single dots. Each integer is between 0 and 255 (inclusive) and cannot have leading zeros.

For example, "0.1.2.201" and "192.168.1.1" are valid IP addresses, but "0.011.255.245", "192.168.1.312" and "192.168@1.1" are invalid IP addresses.

Given a string s containing only digits, return all possible valid IP addresses that can be formed by inserting dots into s. You are not allowed to reorder or remove any digits in s. You may return the valid IP addresses in any order.

Input & Output

Example 1 — Basic Case

$ Input: s = "25525511135"

› Output: ["255.255.11.135","255.255.111.35"]

💡 Note: Two valid IP addresses can be formed: 255.255.11.135 and 255.255.111.35. Each segment is between 0-255 with no leading zeros.

Example 2 — No Valid IPs

$ Input: s = "0000"

› Output: ["0.0.0.0"]

💡 Note: Only one valid IP can be formed: 0.0.0.0. Each segment is exactly '0' which is valid.

Example 3 — Leading Zero Issue

$ Input: s = "101023"

› Output: ["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]

💡 Note: Multiple valid combinations exist. Note that segments like '010' are invalid due to leading zeros.

Constraints

1 ≤ s.length ≤ 20
s consists of digits only

Visualization

Tap to expand

Asked in

F Facebook 35 G Google 25 a Amazon 20

The key insight is that each IP segment must be 0-255 with no leading zeros (except '0' itself). Backtracking provides the optimal approach by systematically trying all valid segment lengths while pruning invalid paths early. Time: O(3⁴), Space: O(4)

Common Approaches

✓ Backtracking - Systematic Exploration

⏱️ Time: O(3⁴) Space: O(4)

Build IP addresses recursively by trying different lengths for each segment, backtracking when invalid segments are found.

Brute Force - Try All Combinations

⏱️ Time: O(n³) Space: O(1)

Generate all possible positions for placing 3 dots to create 4 segments, then validate each combination against IP address rules.

Backtracking - Systematic Exploration — Algorithm Steps

Start with empty IP address
Try segment lengths 1, 2, 3 for current position
Validate each segment before continuing
Backtrack if segment invalid or no more digits

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin with empty path and position 0

Try Lengths

Try segment lengths 1, 2, 3 at current position

Backtrack

Remove invalid segments and try alternatives

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char result[1000][20];
int resultCount = 0;

int isValid(char* segment) {
    int len = strlen(segment);
    if (len == 0 || len > 3) return 0;
    if (len > 1 && segment[0] == '0') return 0;
    int num = atoi(segment);
    return num >= 0 && num <= 255;
}

void backtrack(char* s, int start, char path[][4], int segments) {
    if (segments == 4) {
        if (start == strlen(s)) {
            sprintf(result[resultCount], "%s.%s.%s.%s", path[0], path[1], path[2], path[3]);
            resultCount++;
        }
        return;
    }
    
    if (segments > 4 || start >= strlen(s)) {
        return;
    }
    
    for (int length = 1; length <= 3; length++) {
        if (start + length > strlen(s)) break;
        
        char segment[4];
        strncpy(segment, s + start, length);
        segment[length] = '\0';
        
        if (isValid(segment)) {
            strcpy(path[segments], segment);
            backtrack(s, start + length, path, segments + 1);
        }
    }
}

int main() {
    char s[20];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char path[4][4];
    backtrack(s, 0, path, 0);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3⁴)

At most 3 choices for each of 4 segments, with constant validation work

⚠ Quadratic Growth

Space Complexity

O(4)

Recursion depth is at most 4 (one for each IP segment)

✓ Linear Space

185.0K Views

Medium Frequency

~25 min Avg. Time

3.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking - Systematic Exploration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler