Last Substring in Lexicographical Order - Practice Coding Problems

Last Substring in Lexicographical Order - Problem

Given a string s, you need to find and return the lexicographically largest substring among all possible substrings of s.

In lexicographical order, strings are compared character by character from left to right. For example, "zzb" comes after "zza" because at the third position, 'b' > 'a'. The last substring in lexicographical order is the one that would appear at the end if all substrings were sorted alphabetically.

Example: For string "abab", all substrings are: ["a", "ab", "aba", "abab", "b", "ba", "bab", "a", "ab", "b"]. After removing duplicates and sorting: ["a", "ab", "aba", "abab", "b", "ba", "bab"]. The lexicographically largest is "bab".

Key Insight: The optimal substring must start with the largest character in the string, and we need to find the best starting position among all occurrences of this maximum character.

Input & Output

example_1.py — Basic Example

$ Input: s = "abab"

› Output: "bab"

💡 Note: All substrings are: ["a", "ab", "aba", "abab", "b", "ba", "bab"]. Among these, "bab" is lexicographically largest.

example_2.py — Single Character

$ Input: s = "leetcode"

› Output: "etcode"

💡 Note: The maximum character is 't', but we need to compare all suffixes starting with 'e' (which is the largest character). The suffix "etcode" starting at position 1 is lexicographically largest.

example_3.py — All Same Characters

$ Input: s = "aaaa"

› Output: "aaaa"

💡 Note: When all characters are the same, the entire string is the lexicographically largest substring.

Visualization

Tap to expand

Understanding the Visualization

Identify Candidates

Every position in the string is a potential starting point for the optimal substring

Smart Comparison

Use two pointers to compare suffixes starting at different positions

Eliminate Inferior Options

When one suffix is clearly better, eliminate the worse starting position

Return Winner

The surviving position gives us the lexicographically largest substring

Key Takeaway

🎯 Key Insight: The optimal substring always starts at the position that produces the lexicographically largest suffix. We can find this efficiently using two pointers without generating all possible substrings.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to compare each substring lexicographically

⚠ Quadratic Growth

Space Complexity

O(n²)

Space to store all substrings (there are O(n²) substrings, each of average length O(n))

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 4 × 10⁵
s contains only lowercase English letters
Follow-up: Can you solve this in O(n) time complexity?

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a two-pointers technique to find the best starting position in O(n) time. The key insight is that the lexicographically largest substring must start at the position that gives the largest possible suffix. By comparing candidate positions using two pointers and eliminating inferior ones early, we avoid generating all substrings explicitly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Generate All Substrings	O(n³)	O(n²)	Generate all possible substrings and find the lexicographically maximum one
Optimized Two Pointers Approach	O(n)	O(1)	Use two pointers to find the best starting position among maximum characters

Brute Force - Generate All Substrings — Algorithm Steps

Generate all possible substrings using nested loops
Store all substrings in a list or compare on-the-fly
Find the lexicographically maximum substring
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings using nested loops

Compare Lexicographically

Compare each substring to find the maximum

Return Result

Return the lexicographically largest substring found

Code -

solution.c — C

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

char* lastSubstring(char* s) {
    int n = strlen(s);
    char* maxSubstring = (char*)malloc((n + 1) * sizeof(char));
    maxSubstring[0] = '\0';
    
    // Generate all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            char* substring = (char*)malloc((j - i + 1) * sizeof(char));
            strncpy(substring, s + i, j - i);
            substring[j - i] = '\0';
            
            if (strcmp(substring, maxSubstring) > 0) {
                strcpy(maxSubstring, substring);
            }
            free(substring);
        }
    }
    
    return maxSubstring;
}

int main() {
    char s[100001];
    scanf("%s", s);
    
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    
    char* result = lastSubstring(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to compare each substring lexicographically

⚠ Quadratic Growth

Space Complexity

O(n²)

Space to store all substrings (there are O(n²) substrings, each of average length O(n))

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 4 × 10⁵
s contains only lowercase English letters
Follow-up: Can you solve this in O(n) time complexity?

18.5K Views

Medium Frequency

~25 min Avg. Time

485 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force - Generate All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler