Last Substring in Lexicographical Order

Last Substring in Lexicographical Order - Problem

Given a string s, return the last substring of s in lexicographical order.

A substring is a contiguous sequence of characters within a string. Lexicographical order is the order used in dictionaries - for strings, this means comparing character by character from left to right using their ASCII values.

The last substring lexicographically is the one that would appear last if all possible substrings were sorted in dictionary order.

Input & Output

Example 1 — Basic Case

$ Input: s = "abcab"

› Output: "cab"

💡 Note: All substrings: "a", "ab", "abc", "abca", "abcab", "b", "bc", "bca", "bcab", "c", "ca", "cab", "a", "ab", "b". The lexicographically largest is "cab".

Example 2 — Single Character

$ Input: s = "leetcode"

› Output: "tcode"

💡 Note: Starting from 't' gives us "tcode" which is lexicographically larger than any substring starting with earlier characters like "l" or "e".

Example 3 — Descending Order

$ Input: s = "zab"

› Output: "zab"

💡 Note: The string starts with the largest character 'z', so the entire string "zab" is the lexicographically largest substring.

Constraints

1 ≤ s.length ≤ 4 × 10⁵
s contains only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is that we need to find the starting position that gives us the lexicographically largest suffix. The optimal approach uses two pointers to efficiently compare potential starting positions without generating all substrings. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Generate All Substrings

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

Generate every possible substring of the input string, then sort them lexicographically and return the last one. This approach is straightforward but inefficient for large strings.

Two Pointers Optimization

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

Instead of generating all substrings, use two pointers to compare different starting positions. When we find a position that produces a lexicographically larger substring, we can eliminate the inferior position.

Brute Force - Generate All Substrings — Algorithm Steps

Generate all possible substrings of the input string
Sort all substrings in lexicographical order
Return the last substring from the sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create every possible substring

Sort

Sort all substrings lexicographically

Return Last

The last substring is our answer

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return strcmp(*(char**)a, *(char**)b);
}

char* solution(char* s) {
    int n = strlen(s);
    char** substrings = malloc(n * (n + 1) / 2 * sizeof(char*));
    int count = 0;
    
    // Generate all substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int len = j - i;
            substrings[count] = malloc((len + 1) * sizeof(char));
            strncpy(substrings[count], s + i, len);
            substrings[count][len] = '\0';
            count++;
        }
    }
    
    // Sort lexicographically
    qsort(substrings, count, sizeof(char*), compare);
    
    // Return the last (largest) substring
    char* result = malloc((strlen(substrings[count-1]) + 1) * sizeof(char));
    strcpy(result, substrings[count-1]);
    
    // Free memory
    for (int i = 0; i < count; i++) {
        free(substrings[i]);
    }
    free(substrings);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³ log n)

O(n²) substrings, each of length O(n), sorting takes O(n² log n²) = O(n³ log n)

⚠ Quadratic Growth

Space Complexity

O(n³)

Storing O(n²) substrings, each of average length O(n)

⚠ Quadratic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

856 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 - Generate All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler