Longest Subsequence Repeated k Times - Practice Coding Problems

Longest Subsequence Repeated k Times - Problem

String Backtracking Greedy Counting Enumeration Hard

Find the Longest Subsequence Repeated k Times

You are given a string s of length n and an integer k. Your task is to find the longest subsequence that appears k times in the string.

A subsequence is formed by deleting some (or no) characters from a string without changing the order of remaining characters. A subsequence seq is considered repeated k times if we can find seq * k (seq concatenated k times) as a subsequence of the original string.

Example: In string "bababcba", the subsequence "bba" is repeated 2 times because "bbabba" (bba concatenated twice) can be found as a subsequence by selecting characters at positions that maintain order.

Goal: Return the longest such subsequence. If multiple exist with same length, return the lexicographically largest one.

Input & Output

example_1.py — Basic Example

$ Input: s = "letsleetcode", k = 2

› Output: "eet"

💡 Note: "eet" is a subsequence of "letsleetcode". When repeated 2 times, "eeteet" is also a subsequence of the original string. This is the longest such subsequence.

example_2.py — Single Character

$ Input: s = "bb", k = 2

› Output: "b"

💡 Note: "b" repeated 2 times gives "bb", which is a subsequence of "bb". This is the only valid subsequence that can be repeated k times.

example_3.py — No Solution

$ Input: s = "ab", k = 2

› Output: ""

💡 Note: No character appears at least 2 times, so no subsequence can be repeated 2 times. Return empty string.

Visualization

Tap to expand

EtslETcodE"✓ CASE SOLVED!🏆

Understanding the Visualization

Evidence Collection

Count how many times each letter appears - eliminate letters that don't appear enough times

Pattern Building

Try building patterns starting with the 'best' letters first (Z, Y, X... down to A)

Verification

For each potential pattern, check if it can be found k times in the original message

Key Takeaway

🎯 Key Insight: By filtering out characters that appear less than k times and using backtracking with lexicographic ordering, we can efficiently find the optimal solution without checking every possible subsequence!

Time & Space Complexity

Time Complexity

⏱️

O(k * n * 2^c)

Where c is number of characters appearing at least k times. Each subsequence takes O(k*n) to verify.

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and character frequency counting

⚡ Linearithmic Space

Constraints

n == s.length
2 ≤ k ≤ 2000
2 ≤ n ≤ 2000
s consists of lowercase English letters

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses frequency filtering to eliminate characters appearing less than k times, then applies backtracking with pruning to build subsequences in lexicographically descending order. Key insight: characters with frequency < k cannot be part of any valid solution, drastically reducing the search space.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Pruning (Optimal)	O(k * n * 2^c)	O(n)	Use frequency filtering and backtracking to build the lexicographically largest valid subsequence
Brute Force (Generate All Subsequences)	O(2^n * n * k)	O(2^n)	Generate all possible subsequences and check if each can be repeated k times

Backtracking with Pruning (Optimal) — Algorithm Steps

Count character frequencies and filter out characters appearing less than k times
Use backtracking to build subsequences in lexicographically descending order
For each partial subsequence, check if it can be extended to repeat k times
Prune paths that cannot lead to longer solutions than current best
Return the first valid subsequence found (which will be lexicographically largest)

Visualization

Tap to expand

Step-by-Step Walkthrough

Filter Characters

Remove characters that appear less than k times - they cannot be part of any valid solution

Backtrack by Priority

Build subsequences starting with lexicographically largest characters first

Prune Invalid Paths

Skip paths that cannot lead to better solutions than current best

Code -

solution.c — C

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

#define MAX_LEN 1000

char bestResult[MAX_LEN] = "";

int canRepeatKTimes(char* subseq, char* s, int k) {
    if (strlen(subseq) == 0) return 1;
    
    char target[MAX_LEN * 10];
    target[0] = '\0';
    for (int rep = 0; rep < k; rep++) {
        strcat(target, subseq);
    }
    
    int i = 0, j = 0;
    int sLen = strlen(s), targetLen = strlen(target);
    
    while (i < sLen && j < targetLen) {
        if (s[i] == target[j]) j++;
        i++;
    }
    
    return j == targetLen;
}

void backtrack(char* filteredS, int pos, char* current, int k) {
    if (canRepeatKTimes(current, filteredS, k)) {
        if (strlen(current) > strlen(bestResult) || 
            (strlen(current) == strlen(bestResult) && strcmp(current, bestResult) > 0)) {
            strcpy(bestResult, current);
        }
    }
    
    int seen[256] = {0};
    for (int i = pos; i < strlen(filteredS); i++) {
        char ch = filteredS[i];
        if (seen[(int)ch]) continue;
        seen[(int)ch] = 1;
        
        // Simple pruning
        int remainingLen = strlen(filteredS) - i;
        if (strlen(current) + remainingLen <= strlen(bestResult)) {
            continue;
        }
        
        char newCurrent[MAX_LEN];
        strcpy(newCurrent, current);
        strncat(newCurrent, &ch, 1);
        
        backtrack(filteredS, i + 1, newCurrent, k);
    }
}

char* longestSubsequenceRepeatedK(char* s, int k) {
    int count[256] = {0};
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        count[(int)s[i]]++;
    }
    
    char filteredS[MAX_LEN];
    int filteredLen = 0;
    
    for (int i = 0; i < len; i++) {
        if (count[(int)s[i]] >= k) {
            filteredS[filteredLen++] = s[i];
        }
    }
    filteredS[filteredLen] = '\0';
    
    strcpy(bestResult, "");
    
    // Find unique characters in descending order
    int uniquePresent[256] = {0};
    for (int i = 0; i < filteredLen; i++) {
        uniquePresent[(int)filteredS[i]] = 1;
    }
    
    for (int ch = 255; ch >= 0; ch--) {
        if (uniquePresent[ch]) {
            for (int i = 0; i < filteredLen; i++) {
                if (filteredS[i] == ch) {
                    char start[2] = {ch, '\0'};
                    backtrack(filteredS, i + 1, start, k);
                    break;
                }
            }
        }
    }
    
    return bestResult;
}

int main() {
    char s[MAX_LEN];
    int k;
    
    scanf("%s %d", s, &k);
    
    if (s[0] == '"') {
        int len = strlen(s);
        for (int i = 0; i < len - 2; i++) {
            s[i] = s[i + 1];
        }
        s[len - 2] = '\0';
    }
    
    char* result = longestSubsequenceRepeatedK(s, k);
    printf("\"%s\"", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k * n * 2^c)

Where c is number of characters appearing at least k times. Each subsequence takes O(k*n) to verify.

✓ Linear Growth

Space Complexity

O(n)

Space for recursion stack and character frequency counting

⚡ Linearithmic Space

Constraints

n == s.length
2 ≤ k ≤ 2000
2 ≤ n ≤ 2000
s consists of lowercase English letters

23.5K Views

Medium-High Frequency

~35 min Avg. Time

892 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

Backtracking with Pruning (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler