Maximize Number of Subsequences in a String

Maximize Number of Subsequences in a String - Problem

You are given a string text and a two-character pattern. Your goal is to maximize the number of subsequences that match the pattern by strategically adding exactly one character to the text.

You can add either pattern[0] or pattern[1] anywhere in the text - at the beginning, end, or any position in between. The challenge is to determine which character to add and where to place it for maximum impact.

What is a subsequence? A subsequence preserves the relative order of characters but doesn't need to be contiguous. For example, in "abc", the subsequences include "a", "b", "c", "ab", "ac", "bc", and "abc".

Example: If text = "abdcdbc" and pattern = "ac", adding 'a' at the beginning gives us "aabdcdbc", which contains 4 subsequences of "ac".

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: Adding 'a' at the beginning creates "aabdcdbc". This gives us 4 subsequences of "ac": positions (0,3), (0,4), (1,3), (1,4) where we can pick 'a' and then 'c'.

example_2.py — Same Characters

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

› Output: 6

💡 Note: Adding 'a' at the start gives "aaabb" with 3×2=6 subsequences of "ab". Adding 'b' at the end gives "aabbb" with 2×3=6 subsequences. Both are optimal.

example_3.py — Identical Pattern

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

› Output: 3

💡 Note: With identical pattern characters, we add one more 'a' to get "aaa". The number of ways to choose 2 'a's from 3 is C(3,2) = 3.

Visualization

Tap to expand

Understanding the Visualization

Survey the Line

Count how many students of each type are already in line

Calculate Opportunities

Determine handshake potential for each placement strategy

Optimal Placement

Choose the position that creates the most new handshake pairs

Key Takeaway

🎯 Key Insight: Always choose the placement that maximizes interactions between the new character and existing characters of the opposite type in the pattern!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count characters and subsequences

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

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

Asked in

G Google 23 a Amazon 15 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach with O(n) time complexity. Key insight: only two positions matter - adding pattern[0] at the beginning or pattern[1] at the end. Count existing characters and choose the placement that maximizes new subsequence pairs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Positions)	O(n³)	O(n)	Try inserting each pattern character at every position and count subsequences
Optimal Greedy Approach	O(n)	O(1)	Count characters and use greedy strategy to determine optimal placement

Brute Force (Try All Positions) — Algorithm Steps

Try inserting pattern[0] at each position (0 to n)
For each insertion, count total subsequences matching the pattern
Try inserting pattern[1] at each position
Count subsequences for each insertion
Return the maximum count found

Visualization

Tap to expand

Step-by-Step Walkthrough

Original String

Start with the original text string

Try Pattern[0]

Insert pattern[0] at each position and count subsequences

Try Pattern[1]

Insert pattern[1] at each position and count subsequences

Find Maximum

Return the position and character that gives maximum count

Code -

solution.c — C

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

long long countSubsequences(char* s, char* pattern) {
    long long count = 0;
    long long firstChars = 0;
    char first = pattern[0];
    char second = pattern[1];
    
    for (int i = 0; s[i]; i++) {
        if (s[i] == second) {
            count += firstChars;
        }
        if (s[i] == first) {
            firstChars++;
        }
    }
    return count;
}

long long maximumSubsequenceCount(char* text, char* pattern) {
    long long maxCount = 0;
    int n = strlen(text);
    char* modified = malloc(n + 2);
    
    // Try adding pattern[0] at each position
    for (int i = 0; i <= n; i++) {
        strncpy(modified, text, i);
        modified[i] = pattern[0];
        strcpy(modified + i + 1, text + i);
        
        long long count = countSubsequences(modified, pattern);
        if (count > maxCount) maxCount = count;
    }
    
    // Try adding pattern[1] at each position
    for (int i = 0; i <= n; i++) {
        strncpy(modified, text, i);
        modified[i] = pattern[1];
        strcpy(modified + i + 1, text + i);
        
        long long count = countSubsequences(modified, pattern);
        if (count > maxCount) maxCount = count;
    }
    
    free(modified);
    return maxCount;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

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

⚠ Quadratic Growth

Space Complexity

O(n)

Space for modified string copies

⚡ Linearithmic Space

Constraints

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

18.2K Views

Medium Frequency

~15 min Avg. Time

847 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 (Try All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler