Number of Ways to Separate Numbers - Problem

You wrote down many positive integers in a string called num. However, you realized that you forgot to add commas to separate the different numbers. You remember that the list of integers was non-decreasing and that no integer had leading zeros.

Return the number of possible lists of integers that you could have written down to get the string num. Since the answer may be large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: num = "327"

› Output: 2

💡 Note: Two valid ways: [3, 27] since 3 ≤ 27, and [327] as single number. Cannot use [32, 7] because 32 > 7.

Example 2 — Single Digit

$ Input: num = "9"

› Output: 1

💡 Note: Only one way: [9] as single number.

Example 3 — Leading Zeros

$ Input: num = "094"

› Output: 0

💡 Note: No valid splits because numbers cannot have leading zeros. "094", "09", "04", "0" all have leading zeros.

Constraints

1 ≤ num.length ≤ 3500
num consists of digits only

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12

The key insight is to use dynamic programming to count valid ways to split the string into non-decreasing numbers without leading zeros. Best approach uses 2D DP with optimized string comparison via longest common prefix preprocessing. Time: O(n³), Space: O(n²)

Common Approaches

✓ 2D Dynamic Programming

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

Use bottom-up dynamic programming with a 2D table where dp[i][j] represents the number of ways to split string starting at position i with previous number ending at position j.

Dynamic Programming with Memoization

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

Use top-down dynamic programming with memoization to store results of subproblems. For each position and previous number info, cache the number of ways to complete the sequence.

Recursive Backtracking

⏱️ Time: O(2^n) Space: O(n)

For each position in the string, try all possible lengths for the current number and recursively solve for the remaining string, ensuring the sequence is non-decreasing and has no leading zeros.

2D Dynamic Programming — Algorithm Steps

Create 2D DP table
Precompute LCP for fast string comparison
Fill table bottom-up
Sum valid transitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set base case dp[n][0] = 1

Fill

Process positions from right to left

Sum

Combine all valid ways from dp[0][*]

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 3505

static int dpKeys[MAXN * MAXN][2];
static int dpValues[MAXN * MAXN];
static int dpSize = 0;

int hasLeadingZero(char* num, int start, int length) {
    return length > 1 && num[start] == '0';
}

int compare(char* num, int start1, int len1, int start2, int len2) {
    if (len1 != len2) {
        return len1 < len2 ? -1 : 1;
    }
    
    for (int i = 0; i < len1; i++) {
        if (num[start1 + i] != num[start2 + i]) {
            return num[start1 + i] < num[start2 + i] ? -1 : 1;
        }
    }
    return 0;
}

int findDP(int pos, int prevLen) {
    for (int i = 0; i < dpSize; i++) {
        if (dpKeys[i][0] == pos && dpKeys[i][1] == prevLen) {
            return dpValues[i];
        }
    }
    return -1;
}

void setDP(int pos, int prevLen, int value) {
    dpKeys[dpSize][0] = pos;
    dpKeys[dpSize][1] = prevLen;
    dpValues[dpSize] = value;
    dpSize++;
}

int solve(char* num, int pos, int prevLen, int n) {
    if (pos == n) {
        return 1;
    }
    
    int cached = findDP(pos, prevLen);
    if (cached != -1) {
        return cached;
    }
    
    long long result = 0;
    
    for (int currLen = 1; currLen <= n - pos; currLen++) {
        if (hasLeadingZero(num, pos, currLen)) {
            continue;
        }
        
        if (prevLen > 0) {
            int prevStart = pos - prevLen;
            if (compare(num, prevStart, prevLen, pos, currLen) > 0) {
                continue;
            }
        }
        
        result = (result + solve(num, pos + currLen, currLen, n)) % MOD;
    }
    
    setDP(pos, prevLen, (int)result);
    return (int)result;
}

int solution(char* num) {
    int n = strlen(num);
    
    if (n == 0) {
        return 0;
    }
    
    dpSize = 0;
    return solve(num, 0, 0, n);
}

int main() {
    char num[MAXN];
    fgets(num, sizeof(num), stdin);
    num[strcspn(num, "\n")] = 0;
    
    int result = solution(num);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: position i, previous end j, and current length k

⚠ Quadratic Growth

Space Complexity

O(n²)

2D DP table and LCP preprocessing table both use O(n²) space

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 min Avg. Time

485 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

Number of Ways to Separate Numbers - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

2D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler