Longest Ideal Subsequence

Longest Ideal Subsequence - Problem

You are given a string s consisting of lowercase letters and an integer k. We call a string t ideal if the following conditions are satisfied:

t is a subsequence of the string s.
The absolute difference in the alphabet order of every two adjacent letters in t is less than or equal to k.

Return the length of the longest ideal string.

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.

Note: The alphabet order is not cyclic. For example, the absolute difference in the alphabet order of 'a' and 'z' is 25, not 1.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: The longest ideal string is "acik". Characters a→c (diff=2), c→i (diff=6>2 invalid), but a→c→g→i→k works where a→c (diff=2≤2), c→g invalid, but optimal path is a→c→e→g or similar giving length 4.

Example 2 — Large k

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

› Output: 4

💡 Note: All adjacent characters have difference ≤3: |a-b|=1, |b-c|=1, |c-d|=1. The entire string "abcd" is ideal with length 4.

Example 3 — Small k

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

› Output: 2

💡 Note: Can't include both 'a' and 'z' since |a-z|=25>1. Best subsequences are "ab", "bc", or "ac" (if valid). The longest has length 2.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22

The key insight is to use dynamic programming where dp[c] tracks the longest ideal subsequence ending with character c. For each character, we check all compatible previous characters (within distance k) and extend the best one. Best approach is 1D DP with Time: O(n×k), Space: O(1).

Common Approaches

✓ Brute Force - Generate All Subsequences

⏱️ Time: O(n × 2ⁿ) Space: O(n)

Generate every possible subsequence of the string, then for each subsequence check if adjacent characters have alphabet difference ≤ k. Keep track of the longest valid subsequence found.

Dynamic Programming - 1D Array

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

Use dynamic programming where dp[c] represents the maximum length of ideal subsequence ending with character c. For each character in the string, check all compatible previous characters (within distance k) and extend the best one.

Optimized DP - Range Query

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

Optimize the DP approach by using a data structure that can efficiently find the maximum value in a range of characters. Instead of checking all 26 characters, we only query the range [char-k, char+k] to find the best previous character to extend.

Brute Force - Generate All Subsequences — Algorithm Steps

Generate all 2^n possible subsequences using bit manipulation
For each subsequence, check if adjacent characters satisfy |char1 - char2| ≤ k
Track the maximum length among all valid ideal subsequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all 2^n possible subsequences

Validate

Check adjacent character differences ≤ k

Track Max

Keep the longest valid subsequence length

Code -

solution.c — C

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

int solution(char* s, int k) {
    int n = strlen(s);
    int maxLength = 0;
    
    // Generate all possible subsequences using bit manipulation
    for (int mask = 1; mask < (1 << n); mask++) {
        char subsequence[1001];
        int subLen = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subsequence[subLen++] = s[i];
            }
        }
        subsequence[subLen] = '\0';
        
        // Check if this subsequence is ideal
        int isIdeal = 1;
        for (int i = 1; i < subLen; i++) {
            if (abs(subsequence[i] - subsequence[i-1]) > k) {
                isIdeal = 0;
                break;
            }
        }
        
        if (isIdeal && subLen > maxLength) {
            maxLength = subLen;
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    int k;
    
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &k);
    
    int result = solution(s, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2ⁿ)

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

✓ Linear Growth

Space Complexity

O(n)

Space for storing current subsequence being checked

✓ Linear Space

28.5K Views

Medium Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler