Partition Labels

Partition Labels - Problem

You are given a string s. We want to partition the string into as many parts as possible so that each letter appears in at most one part.

For example, the string "ababcc" can be partitioned into ["abab", "cc"], but partitions such as ["aba", "bcc"] or ["ab", "ab", "cc"] are invalid.

Note that the partition is done so that after concatenating all the parts in order, the resultant string should be s.

Return a list of integers representing the size of these parts.

Input & Output

Example 1 — Basic Partitioning

$ Input: s = "ababcbaca"

› Output: [4,5]

💡 Note: The string can be partitioned into "abab" and "cbaca". The first partition contains all 'a' and 'b' characters, while the second contains all 'c' characters and remaining 'a's.

Example 2 — Simple Case

$ Input: s = "eccbbbbdec"

› Output: [10]

💡 Note: All characters appear throughout the string, so we cannot partition it further. The entire string must be one partition of length 10.

Example 3 — Maximum Partitions

$ Input: s = "abcdef"

› Output: [1,1,1,1,1,1]

💡 Note: Each character appears only once, so we can partition into 6 parts, each containing exactly one character.

Constraints

1 ≤ s.length ≤ 500
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 35 f Facebook 28 M Microsoft 22

The key insight is to track the last occurrence of each character and greedily extend partitions until we can safely make a cut. The optimal approach uses a greedy strategy with hash map preprocessing. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Partitions

⏱️ Time: O(2ⁿ × n²) Space: O(n)

Try every possible way to partition the string and check if each partition satisfies the constraint that no letter appears in multiple parts.

Greedy Approach

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

Process characters one by one, maintaining the furthest position we need to reach for the current partition. When we reach that position, we can safely end the current partition.

Two-Pass Hash Map

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

Use a hash map to record the last occurrence of each character, then scan through the string to determine partition boundaries based on the furthest last occurrence within current partition.

Brute Force - Try All Partitions — Algorithm Steps

Generate all possible partitions
For each partition, check if any letter appears in multiple parts
Return the valid partition with maximum number of parts

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Partitions

Try every possible way to split the string

Validate Each

Check if any character appears in multiple parts

Find Maximum

Return the valid partition with most parts

Code -

solution.c — C

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

#define MAX_LEN 500

typedef struct {
    int* sizes;
    int count;
} Result;

bool isValidPartition(char parts[][MAX_LEN], int partCount) {
    bool seen[26] = {false};
    for (int i = 0; i < partCount; i++) {
        bool charsInPart[26] = {false};
        for (int j = 0; parts[i][j]; j++) {
            charsInPart[parts[i][j] - 'a'] = true;
        }
        for (int c = 0; c < 26; c++) {
            if (charsInPart[c] && seen[c]) return false;
        }
        for (int c = 0; c < 26; c++) {
            if (charsInPart[c]) seen[c] = true;
        }
    }
    return true;
}

Result generatePartitions(char* s, int start, char parts[][MAX_LEN], int partCount, int* bestSizes, int* bestCount) {
    Result result = {NULL, 0};
    
    if (start == strlen(s)) {
        if (isValidPartition(parts, partCount)) {
            result.sizes = (int*)malloc(partCount * sizeof(int));
            result.count = partCount;
            for (int i = 0; i < partCount; i++) {
                result.sizes[i] = strlen(parts[i]);
            }
        }
        return result;
    }
    
    Result best = {NULL, 0};
    for (int end = start + 1; end <= strlen(s); end++) {
        strncpy(parts[partCount], s + start, end - start);
        parts[partCount][end - start] = '\0';
        
        Result current = generatePartitions(s, end, parts, partCount + 1, bestSizes, bestCount);
        if (current.sizes && (best.sizes == NULL || current.count > best.count)) {
            if (best.sizes) free(best.sizes);
            best = current;
        } else if (current.sizes) {
            free(current.sizes);
        }
    }
    
    return best;
}

Result solution(char* s) {
    char parts[MAX_LEN][MAX_LEN];
    int bestSizes[MAX_LEN];
    int bestCount = 0;
    return generatePartitions(s, 0, parts, 0, bestSizes, &bestCount);
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    Result result = solution(s);
    
    printf("[");
    for (int i = 0; i < result.count; i++) {
        if (i > 0) printf(",");
        printf("%d", result.sizes[i]);
    }
    printf("]\n");
    
    if (result.sizes) free(result.sizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ × n²)

2ⁿ possible partitions, each taking O(n²) to validate

✓ Linear Growth

Space Complexity

O(n)

Storage for current partition and character sets

✓ Linear Space

269.4K Views

High Frequency

~15 min Avg. Time

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