Find the Lexicographically Largest String From the Box II

Find the Lexicographically Largest String From the Box II - Problem

You are given a string word and an integer numFriends. Alice is organizing a game for her numFriends friends.

There are multiple rounds in the game, where in each round:

The string word is split into numFriends non-empty strings, such that no previous round has had the exact same split.
All the split words are put into a box.

Find the lexicographically largest string from the box after all the rounds are finished.

A string a is lexicographically smaller than a string b if in the first position where a and b differ, string a has a letter that appears earlier in the alphabet than the corresponding letter in b. If the first min(a.length, b.length) characters do not differ, then the shorter string is the lexicographically smaller one.

Input & Output

Example 1 — Basic Case

$ Input: word = "abc", numFriends = 2

› Output: "bc"

💡 Note: Possible splits: ["a","bc"], ["ab","c"]. All substrings: "a", "bc", "ab", "c". The lexicographically largest is "bc".

Example 2 — Single Friend

$ Input: word = "hello", numFriends = 1

› Output: "hello"

💡 Note: With only 1 friend, the entire word goes to one person, so the answer is "hello".

Example 3 — Multiple Splits

$ Input: word = "zyab", numFriends = 3

› Output: "zy"

💡 Note: Possible splits: ["z","y","ab"], ["z","ya","b"], ["zy","a","b"]. All substrings: "z", "y", "ab", "ya", "zy", "a", "b". The lexicographically largest is "zy".

Constraints

1 ≤ word.length ≤ 50
1 ≤ numFriends ≤ word.length
word consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is that the lexicographically largest substring will always be a valid suffix of the original string. Best approach is the optimized mathematical solution that checks each valid suffix position. Time: O(n²), Space: O(1)

Common Approaches

✓ Generate All Splits

⏱️ Time: O(C(n-1,k-1) × n) Space: O(C(n-1,k-1) × n)

Generate all ways to split the word into numFriends non-empty parts, collect all substrings, and return the lexicographically largest one.

Mathematical Optimization

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

Instead of generating all splits, we observe that the lexicographically largest substring will always be a suffix of the original string starting from the position with the largest character.

Generate All Splits — Algorithm Steps

Generate all possible split positions
For each split, create substrings
Track the lexicographically largest substring found

Visualization

Tap to expand

Step-by-Step Walkthrough

Input

word = 'abc', numFriends = 2

Generate Splits

All ways to split into 2 parts: ['a','bc'], ['ab','c']

Find Maximum

Compare all substrings: 'bc' is lexicographically largest

Code -

solution.c — C

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

void getCombinations(int* arr, int arrSize, int k, int start, int* current, int currentSize, int*** result, int* resultSize, int** resultColSizes) {
    if (k == 0) {
        (*result)[*resultSize] = (int*)malloc(currentSize * sizeof(int));
        memcpy((*result)[*resultSize], current, currentSize * sizeof(int));
        (*resultColSizes)[*resultSize] = currentSize;
        (*resultSize)++;
        return;
    }
    
    for (int i = start; i <= arrSize - k; i++) {
        current[currentSize] = arr[i];
        getCombinations(arr, arrSize, k - 1, i + 1, current, currentSize + 1, result, resultSize, resultColSizes);
    }
}

char* solution(char* word, int numFriends) {
    int n = strlen(word);
    if (numFriends == 1) {
        char* result = (char*)malloc((n + 1) * sizeof(char));
        strcpy(result, word);
        return result;
    }
    
    char* maxString = (char*)malloc((n + 1) * sizeof(char));
    maxString[0] = '\0';
    
    int* positions = (int*)malloc((n - 1) * sizeof(int));
    for (int i = 1; i < n; i++) {
        positions[i - 1] = i;
    }
    
    int** combinations = (int**)malloc(10000 * sizeof(int*));
    int* combinationSizes = (int*)malloc(10000 * sizeof(int));
    int combinationCount = 0;
    int* current = (int*)malloc((numFriends - 1) * sizeof(int));
    
    getCombinations(positions, n - 1, numFriends - 1, 0, current, 0, &combinations, &combinationCount, &combinationSizes);
    
    for (int i = 0; i < combinationCount; i++) {
        int prev = 0;
        for (int j = 0; j < combinationSizes[i]; j++) {
            int pos = combinations[i][j];
            char* substring = (char*)malloc((pos - prev + 1) * sizeof(char));
            strncpy(substring, word + prev, pos - prev);
            substring[pos - prev] = '\0';
            
            if (strcmp(substring, maxString) > 0) {
                strcpy(maxString, substring);
            }
            free(substring);
            prev = pos;
        }
        
        char* substring = (char*)malloc((n - prev + 1) * sizeof(char));
        strcpy(substring, word + prev);
        if (strcmp(substring, maxString) > 0) {
            strcpy(maxString, substring);
        }
        free(substring);
        free(combinations[i]);
    }
    
    free(positions);
    free(combinations);
    free(combinationSizes);
    free(current);
    
    return maxString;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(C(n-1,k-1) × n)

Generate all ways to choose k-1 split positions from n-1 possible positions, process each substring

⚠ Quadratic Growth

Space Complexity

O(C(n-1,k-1) × n)

Store all possible substrings from all splits

✓ Linear Space

12.5K Views

Medium Frequency

~35 min Avg. Time

284 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

Generate All Splits — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler