Optimal Partition of String - Practice Coding Problems

Optimal Partition of String - Problem

Given a string s, partition the string into one or more substrings such that the characters in each substring are unique. That is, no letter appears in a single substring more than once.

Return the minimum number of substrings in such a partition.

Note that each character should belong to exactly one substring in a partition.

Input & Output

Example 1 — Basic Case

$ Input: s = "abcabc"

› Output: 2

💡 Note: Split into "abc" and "abc". Each substring has unique characters. We cannot do better than 2 partitions because 'a' appears again at position 3.

Example 2 — All Unique

$ Input: s = "abcd"

› Output: 1

💡 Note: All characters are unique, so we only need 1 partition containing the entire string.

Example 3 — All Same

$ Input: s = "aaaa"

› Output: 4

💡 Note: Every character is the same, so each must be in its own partition: "a", "a", "a", "a".

Constraints

1 ≤ s.length ≤ 1000
s consists of only English lowercase letters

Visualization

Tap to expand

Understanding the Visualization

Input

String that may contain duplicate characters

Process

Partition at duplicate character boundaries

Output

Minimum number of partitions needed

Key Takeaway

🎯 Key Insight: Use greedy approach - partition only when necessary (at duplicate characters)

Asked in

a Amazon 35 G Google 25 M Microsoft 20

The key insight is to use a greedy approach: scan left to right and start a new partition whenever we encounter a duplicate character. This minimizes partitions because we make each partition as long as possible. Best approach is Greedy with Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Partitions	O(2ⁿ × n)	O(n)	Generate all possible partitions and find the one with minimum count
Greedy Approach	O(n)	O(1)	Scan left to right, start new partition when duplicate found

Brute Force - Try All Partitions — Algorithm Steps

Generate all possible partitions of the string
For each partition, verify all substrings have unique characters
Track the minimum partition count among valid partitions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Create all possible ways to split the string

Validate Each

Check if each partition has unique characters

Find Minimum

Return the partition with minimum count

Code -

solution.c — C

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

bool hasUniqueChars(const char* substring) {
    bool seen[256] = {false};
    for (int i = 0; substring[i]; i++) {
        if (seen[(unsigned char)substring[i]]) return false;
        seen[(unsigned char)substring[i]] = true;
    }
    return true;
}

int backtrack(const char* s, int index, char partitions[][1001], int partitionCount, int len) {
    if (index == len) {
        for (int i = 0; i < partitionCount; i++) {
            if (!hasUniqueChars(partitions[i])) return 1000000;
        }
        return partitionCount;
    }
    
    int minCount = 1000000;
    // Try all possible end positions for current substring
    for (int end = index + 1; end <= len; end++) {
        strncpy(partitions[partitionCount], s + index, end - index);
        partitions[partitionCount][end - index] = '\0';
        
        int count = backtrack(s, end, partitions, partitionCount + 1, len);
        if (count < minCount) minCount = count;
    }
    
    return minCount;
}

int solution(const char* s) {
    char partitions[1001][1001];
    return backtrack(s, 0, partitions, 0, strlen(s));
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n)

2ⁿ possible partitions, each takes O(n) time to validate

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and temporary storage for partitions

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Brute Force - Try All Partitions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler