Longest Ideal Subsequence - Practice Coding Problems

Longest Ideal Subsequence - Problem

Given a string s consisting of lowercase letters and an integer k, you need to find the longest ideal subsequence.

A subsequence is ideal if:

It maintains the original order of characters from s
The absolute difference between any two adjacent characters in the alphabet is at most k

For example, if k = 2, then 'a' can be followed by 'a', 'b', or 'c' (since |ord('c') - ord('a')| = 2 ≤ k).

Goal: Return the length of the longest possible ideal subsequence.

Note: The alphabet is not cyclic - the distance between 'a' and 'z' is 25, not 1.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: The longest ideal subsequence is "acbd" with length 4. Adjacent differences: |c-a|=2, |b-c|=1, |d-b|=2, all ≤ k=2.

example_2.py — Small k

$ Input: s = "abcd", k = 3

› Output: 4

💡 Note: The entire string "abcd" is ideal since consecutive letters have difference 1 ≤ k=3.

example_3.py — Large Gap

$ Input: s = "azbc", k = 1

› Output: 2

💡 Note: Cannot include both 'a' and 'z' (difference = 25 > k=1). Best subsequences are "ab" or "bc", both length 2.

Constraints

1 ≤ s.length ≤ 10⁵
0 ≤ k ≤ 25
s consists of lowercase English letters only

Visualization

Tap to expand

Understanding the Visualization

Track Chain Endings

Keep track of the longest chain ending with each 'age group' (character)

Extend Compatible Chains

When a new person arrives, they can extend any compatible chain

Update Best Chain

Update the longest chain ending with this person's age

Find Global Maximum

The answer is the longest chain among all age groups

Key Takeaway

🎯 Key Insight: Each character can extend the longest compatible subsequence, creating an optimal substructure that makes dynamic programming the perfect approach with O(n×k) efficiency.

Asked in

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

The optimal solution uses dynamic programming with a fixed-size array to track the longest ideal subsequence ending with each character. For each character, we check all compatible characters (within distance k) and extend the best existing subsequence, achieving O(n × k) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subsequences)	O(2^n × n)	O(n)	Generate all possible subsequences and check if each one is ideal
Dynamic Programming (Optimal)	O(n × 26k)	O(26)	Track the longest ideal subsequence ending at each character using DP

Brute Force (Try All Subsequences) — Algorithm Steps

Generate all possible subsequences using bit manipulation or recursion
For each subsequence, check if adjacent characters differ by at most k
Keep track of the maximum length found
Return the maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequence

Use bitmask to select characters from original string

Validate Ideal Property

Check if adjacent characters differ by at most k

Update Maximum

Keep track of the longest valid subsequence found

Code -

solution.c — C

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

int isIdeal(char* subseq, int len, int k) {
    if (len <= 1) return 1;
    
    for (int i = 1; i < len; i++) {
        if (abs(subseq[i] - subseq[i-1]) > k) {
            return 0;
        }
    }
    return 1;
}

int longestIdealString(char* s, int k) {
    int n = strlen(s);
    int maxLength = 0;
    
    for (int mask = 0; mask < (1 << n); mask++) {
        char subsequence[1001];
        int len = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[len++] = s[i];
            }
        }
        
        if (isIdeal(subsequence, len, k)) {
            if (len > maxLength) {
                maxLength = len;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    int k;
    scanf("%s %d", s, &k);
    printf("%d\n", longestIdealString(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × n)

2^n subsequences to generate, each taking O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and temporary subsequence storage

⚡ Linearithmic Space

47.0K Views

Medium-High Frequency

~18 min Avg. Time

1.9K 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 Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler