Partition String Into Substrings With Values at Most K

Partition String Into Substrings With Values at Most K - Problem

You're tasked with breaking down a string of digits into the minimum number of valid pieces. Given a string s containing only digits from 1 to 9 and an integer k, you need to partition the string such that:

Every digit belongs to exactly one substring
When each substring is interpreted as an integer, its value must be ≤ k
You want the fewest possible substrings

For example, if s = "165334" and k = 60, you could partition it as ["1", "6", "53", "3", "4"] (5 parts) or ["16", "53", "34"] (3 parts). The second partition is better! Return the minimum number of substrings needed, or -1 if no valid partition exists.

Input & Output

example_1.py — Basic partition

$ Input: s = "165334", k = 60

› Output: 3

💡 Note: We can partition as ["16", "53", "34"]. All values (16, 53, 34) are ≤ 60, giving us 3 partitions total.

example_2.py — Impossible case

$ Input: s = "238", k = 4

› Output: -1

💡 Note: No valid partition exists because even single digits like 8 exceed k=4, making it impossible to satisfy the constraint.

example_3.py — Single character partitions

$ Input: s = "123", k = 1

› Output: 3

💡 Note: Each digit must be its own partition: ["1", "2", "3"], since combining any two would exceed k=1.

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of digits from '1' to '9'
1 ≤ k ≤ 10⁹
No leading zeros in any partition

Visualization

Tap to expand

Understanding the Visualization

Greedy Path

Takes longest valid substring at each step

Exhaustive Search

Explores all possible partitions

Efficiency Gain

Greedy is O(n) vs O(2^n) for brute force

Key Takeaway

🎯 Key Insight: Greedy algorithm achieves optimal results in linear time by always choosing the longest valid substring, proving that being locally optimal leads to global optimality in this problem.

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 22

This problem is optimally solved using a greedy approach in O(n) time. The key insight is to always take the longest possible substring that doesn't exceed k, as delaying cuts never makes future decisions worse. The dynamic programming solution also works in O(n²) time but uses more space.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive Backtracking	O(2^n)	O(n)	Try every possible partition and find the minimum
Dynamic Programming (Bottom-Up)	O(n²)	O(n)	Build solution table from right to left using previously computed results
Greedy Algorithm (Optimal)	O(n)	O(1)	Always take the longest valid substring at each step

Recursive Backtracking — Algorithm Steps

Start from the beginning of string
Try every possible first substring (1 char, 2 chars, etc.)
For each valid first substring, recursively solve the remaining string
Return minimum partitions across all possibilities
Use memoization to avoid recalculating subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at the start of string, consider all possible first substrings

Branch Creation

For each valid first substring, create a branch to solve remaining string

Pruning

Stop branching when substring value exceeds k

Memoization

Cache results to avoid recalculating same subproblems

Code -

solution.c — C

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

int memo[10001];
char* str;
int target;

int solve(int start, int len) {
    if (start == len) {
        return 0;
    }
    
    if (memo[start] != -1) {
        return memo[start];
    }
    
    int result = INT_MAX;
    long long currentNum = 0;
    
    for (int end = start; end < len; end++) {
        currentNum = currentNum * 10 + (str[end] - '0');
        
        if (currentNum > target) {
            break;
        }
        
        int remaining = solve(end + 1, len);
        if (remaining != INT_MAX) {
            int candidate = 1 + remaining;
            if (candidate < result) {
                result = candidate;
            }
        }
    }
    
    return memo[start] = result;
}

int minimumPartition(char* s, int k) {
    str = s;
    target = k;
    int len = strlen(s);
    
    for (int i = 0; i <= len; i++) {
        memo[i] = -1;
    }
    
    int result = solve(0, len);
    return result == INT_MAX ? -1 : result;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Without memoization, we try every possible partition which is exponential. With memoization, it becomes O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and memoization table both proportional to string length

⚡ Linearithmic Space

38.2K Views

Medium-High Frequency

~15 min Avg. Time

1.5K 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

Recursive Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler