Longest Duplicate Substring - Problem

String Binary Search Sliding Window Rolling Hash Suffix Array Hash Function Hard

Given a string s, consider all duplicated substrings: (contiguous) substrings of s that occur 2 or more times. The occurrences may overlap.

Return any duplicated substring that has the longest possible length. If s does not have a duplicated substring, the answer is "".

Input & Output

Example 1 — Basic Case

$ Input: s = "banana"

› Output: "ana"

💡 Note: "ana" appears twice in "banana" at positions 1-3 and 3-5. It's the longest substring that appears more than once.

Example 2 — No Duplicates

$ Input: s = "abcd"

› Output: ""

💡 Note: No substring appears more than once, so return empty string.

Example 3 — Single Character

$ Input: s = "aa"

› Output: "a"

💡 Note: Character 'a' appears twice, making it the longest (and only) duplicate substring.

Constraints

2 ≤ s.length ≤ 3 × 10⁴
s consists of lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15 M Microsoft 12

The key insight is using binary search on the answer length combined with polynomial rolling hash for efficient duplicate detection. The optimal approach achieves O(n² log n) time complexity by searching for the maximum length that has duplicates.

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Prefix Sum

⏱️ Time: N/A Space: N/A

Binary Search + Rolling Hash

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

Use binary search to find the maximum length that has duplicates. For each length, use polynomial rolling hash to efficiently check if any substring of that length appears more than once.

Brute Force

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

Generate all possible substrings and check if each appears more than once. Start from longest possible length and work down to find the longest duplicate.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    long long hash;
    int index;
} HashEntry;

typedef struct {
    HashEntry* entries;
    int size;
    int capacity;
} HashMap;

HashMap* createHashMap(int capacity) {
    HashMap* map = malloc(sizeof(HashMap));
    map->entries = malloc(sizeof(HashEntry) * capacity);
    map->size = 0;
    map->capacity = capacity;
    return map;
}

void freeHashMap(HashMap* map) {
    free(map->entries);
    free(map);
}

int findInHashMap(HashMap* map, long long hash) {
    for (int i = 0; i < map->size; i++) {
        if (map->entries[i].hash == hash) {
            return map->entries[i].index;
        }
    }
    return -1;
}

void addToHashMap(HashMap* map, long long hash, int index) {
    if (map->size < map->capacity) {
        map->entries[map->size].hash = hash;
        map->entries[map->size].index = index;
        map->size++;
    }
}

typedef struct {
    int found;
    char* substring;
} DuplicateResult;

DuplicateResult hasDuplicateOfLength(const char* s, int length) {
    int n = strlen(s);
    DuplicateResult result;
    
    if (length == 0) {
        result.found = 1;
        result.substring = malloc(1);
        result.substring[0] = '\0';
        return result;
    }
    
    // Rolling hash parameters
    long long base = 31;
    long long mod = 1000000007LL;
    
    // Compute hash for first substring of given length
    long long hashVal = 0;
    long long basePow = 1;
    
    for (int i = 0; i < length; i++) {
        hashVal = (hashVal * base + (s[i] - 'a' + 1)) % mod;
        if (i < length - 1) {
            basePow = (basePow * base) % mod;
        }
    }
    
    HashMap* seen = createHashMap(n);
    addToHashMap(seen, hashVal, 0);
    
    // Rolling hash for remaining substrings
    for (int i = 1; i <= n - length; i++) {
        // Remove leftmost character and add rightmost character
        hashVal = (hashVal - ((s[i-1] - 'a' + 1) * basePow) % mod + mod) % mod;
        hashVal = (hashVal * base + (s[i + length - 1] - 'a' + 1)) % mod;
        
        if (findInHashMap(seen, hashVal) != -1) {
            // Found duplicate, return the substring
            result.found = 1;
            result.substring = malloc(length + 1);
            strncpy(result.substring, s + i, length);
            result.substring[length] = '\0';
            freeHashMap(seen);
            return result;
        }
        addToHashMap(seen, hashVal, i);
    }
    
    freeHashMap(seen);
    result.found = 0;
    result.substring = malloc(1);
    result.substring[0] = '\0';
    return result;
}

char* solution(const char* s) {
    int n = strlen(s);
    if (n <= 1) {
        char* result = malloc(1);
        result[0] = '\0';
        return result;
    }
    
    // Binary search on length
    int left = 0, right = n - 1;
    char* result = malloc(n + 1);
    result[0] = '\0';
    
    while (left <= right) {
        int mid = (left + right) / 2;
        DuplicateResult dupResult = hasDuplicateOfLength(s, mid);
        
        if (dupResult.found) {
            if (mid > 0) {  // Only update result for non-empty substrings
                strcpy(result, dupResult.substring);
            }
            left = mid + 1;
        } else {
            right = mid - 1;
        }
        
        free(dupResult.substring);
    }
    
    return result;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline if present
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.6K Views

Medium Frequency

~35 min Avg. Time

891 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