Maximize Number of Subsequences in a String

Maximize Number of Subsequences in a String - Problem

You are given a 0-indexed string text and another 0-indexed string pattern of length 2, both of which consist of only lowercase English letters.

You can add either pattern[0] or pattern[1] anywhere in text exactly once. Note that the character can be added even at the beginning or at the end of text.

Return the maximum number of times pattern can occur as a subsequence of the modified text.

A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

Input & Output

Example 1 — Basic Case

$ Input: text = "abdcdbc", pattern = "ac"

› Output: 4

💡 Note: Adding 'a' at the start gives "aabdcdbc". We can form "ac" subsequences: positions (0,4), (0,6), (1,4), (1,6) = 4 total.

Example 2 — Same Characters

$ Input: text = "aabb", pattern = "ab"

› Output: 6

💡 Note: Adding 'a' at start gives "aaabb" with 3 'a's and 2 'b's. Total subsequences = 3 × 2 = 6.

Example 3 — Identical Pattern

$ Input: text = "aa", pattern = "aa"

› Output: 3

💡 Note: Adding another 'a' gives 3 'a's total. Number of ways to choose 2 from 3 = C(3,2) = 3.

Constraints

1 ≤ text.length ≤ 10⁵
pattern.length == 2
text and pattern consist of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that adding pattern[0] at the beginning or pattern[1] at the end typically gives optimal results. Best approach uses greedy counting to calculate benefits of each insertion without trying all positions. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Positions

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

For each character in pattern, try inserting it at every possible position in text (including start and end). For each insertion, count how many times pattern appears as a subsequence in the modified string.

Greedy with Prefix Counting

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

Count occurrences of pattern[0] and pattern[1] in text. Use prefix counting to calculate how many new subsequences each insertion would create. Choose the insertion that maximizes total subsequences.

Brute Force - Try All Positions — Algorithm Steps

Try inserting pattern[0] at each position (0 to text.length)
Count subsequences in each modified string
Try inserting pattern[1] at each position
Return maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try pattern[0]

Insert first character at each position

Try pattern[1]

Insert second character at each position

Count Maximum

Return highest subsequence count

Code -

solution.c — C

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

int countSubsequences(const char* text, const char* pattern) {
    int len = strlen(text);
    if (pattern[0] == pattern[1]) {
        // Special case: pattern has identical characters
        int count = 0;
        for (int i = 0; i < len; i++) {
            if (text[i] == pattern[0]) count++;
        }
        return count * (count - 1) / 2;
    } else {
        // Count pattern[0] followed by pattern[1]
        int count = 0;
        int countFirst = 0;
        for (int i = 0; i < len; i++) {
            if (text[i] == pattern[0]) {
                countFirst++;
            } else if (text[i] == pattern[1]) {
                count += countFirst;
            }
        }
        return count;
    }
}

int solution(const char* text, const char* pattern) {
    int textLen = strlen(text);
    int maxCount = 0;
    char newText[100010];
    
    // Try adding pattern[0] at each possible position
    for (int i = 0; i <= textLen; i++) {
        strncpy(newText, text, i);
        newText[i] = pattern[0];
        strcpy(newText + i + 1, text + i);
        int count = countSubsequences(newText, pattern);
        if (count > maxCount) maxCount = count;
    }
    
    // Try adding pattern[1] (only if different from pattern[0])
    if (pattern[0] != pattern[1]) {
        for (int i = 0; i <= textLen; i++) {
            strncpy(newText, text, i);
            newText[i] = pattern[1];
            strcpy(newText + i + 1, text + i);
            int count = countSubsequences(newText, pattern);
            if (count > maxCount) maxCount = count;
        }
    }
    
    return maxCount;
}

int main() {
    char text[100001], pattern[3];
    fgets(text, sizeof(text), stdin);
    fgets(pattern, sizeof(pattern), stdin);
    
    // Remove newlines
    text[strcspn(text, "\n")] = 0;
    pattern[strcspn(pattern, "\n")] = 0;
    
    int result = solution(text, pattern);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) positions × O(n²) subsequence counting for each position

✓ Linear Growth

Space Complexity

O(n)

Creating modified strings for each position

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

823 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 - Try All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler