Longest Palindromic Subsequence After at Most K Operations

Longest Palindromic Subsequence After at Most K Operations - Problem

You're given a string s and an integer k. Your goal is to find the longest palindromic subsequence possible after performing at most k character transformations.

In each operation, you can transform any character to its next or previous letter in the alphabet (with wraparound). For example:

'a' → 'b' (next) or 'a' → 'z' (previous)
'z' → 'a' (next) or 'z' → 'y' (previous)
'm' → 'n' (next) or 'm' → 'l' (previous)

Key insight: You need to strategically use your k operations to create the longest possible palindromic subsequence. Remember, a subsequence doesn't need to be contiguous, but it must maintain the original relative order of characters.

Input & Output

example_1.py — Basic transformation

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

› Output: 4

💡 Note: We can transform 'a'→'d' (cost: min(3,23)=3 > k) or 'b'→'c' (cost: 1 ≤ k). Better approach: transform 'a'→'b' (cost: 1) and 'd'→'c' (cost: 1), making "bbcc". The longest palindromic subsequence is "bccb" with length 4.

example_2.py — Wraparound case

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

› Output: 3

💡 Note: The string is already "aaa", which is itself a palindrome. No operations needed, so the longest palindromic subsequence has length 3.

example_3.py — Limited operations

$ Input: s = "abc", k = 0

› Output: 1

💡 Note: With k=0, no transformations are allowed. The original string "abc" has no repeated characters, so the longest palindromic subsequence is any single character, giving length 1.

Constraints

1 ≤ s.length ≤ 1000
0 ≤ k ≤ 1000
s consists only of lowercase English letters
Time limit: 2 seconds per test case

Visualization

Tap to expand

Understanding the Visualization

Identify potential pairs

Look at characters from both ends that could form palindromic pairs

Calculate transformation costs

For each pair, find the minimum operations needed to make them identical

Choose optimal strategy

Decide whether to transform pairs or skip characters based on operation budget

Build longest palindrome

Construct the longest possible palindromic subsequence within constraints

Key Takeaway

🎯 Key Insight: Calculate minimum circular alphabet distance between character pairs and use dynamic programming to find the optimal combination of transformations within the operation budget.

Asked in

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

The optimal solution uses dynamic programming with memoization. We define dp[i][j][k] as the maximum palindromic subsequence length in substring s[i..j] using at most k operations. For each character pair, we calculate the minimum circular distance and decide whether to include both characters (if cost ≤ k) or skip one of them. The key insight is that transforming characters optimally requires considering the wraparound alphabet distance.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization	O(n² × k)	O(n² × k)	Use DP to find optimal palindromic subsequence considering transformation costs
Brute Force (Try All Transformations)	O(26^k × n²)	O(n²)	Generate all possible strings after k operations and find longest palindromic subsequence

Dynamic Programming with Memoization — Algorithm Steps

Define DP state: dp[i][j][k] = max length palindromic subsequence in s[i..j] using at most k operations
For each character pair, calculate minimum operations needed to make them equal
If characters can be made equal within k operations, include both in palindrome
Otherwise, try including only left or only right character
Return dp[0][n-1][k]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Create 3D table for positions i, j and operations k

Base cases

Handle single characters and empty ranges

Recurrence relation

Choose between skipping characters or matching them

Memoization

Store results to avoid recomputation

Code -

solution.c — C

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

#define MAX_LEN 1000
#define MAX_K 1000

int memo[MAX_LEN][MAX_LEN][MAX_K + 1];
int visited[MAX_LEN][MAX_LEN][MAX_K + 1];

int minOperations(char c1, char c2) {
    int diff = abs(c1 - c2);
    return diff < 26 - diff ? diff : 26 - diff;
}

int dp(char* s, int i, int j, int ops, int n) {
    if (i > j) return 0;
    if (i == j) return 1;
    
    if (visited[i][j][ops]) {
        return memo[i][j][ops];
    }
    
    visited[i][j][ops] = 1;
    int result = 0;
    
    // Option 1: Skip left character
    int val1 = dp(s, i + 1, j, ops, n);
    if (val1 > result) result = val1;
    
    // Option 2: Skip right character
    int val2 = dp(s, i, j - 1, ops, n);
    if (val2 > result) result = val2;
    
    // Option 3: Try to match s[i] and s[j]
    int cost = minOperations(s[i], s[j]);
    if (cost <= ops) {
        int val3 = 2 + dp(s, i + 1, j - 1, ops - cost, n);
        if (val3 > result) result = val3;
    }
    
    memo[i][j][ops] = result;
    return result;
}

int longestPalindromeSubseq(char* s, int k) {
    int n = strlen(s);
    memset(visited, 0, sizeof(visited));
    return dp(s, 0, n - 1, k, n);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n² × k)

Three nested loops for position i, j, and operations k

⚠ Quadratic Growth

Space Complexity

O(n² × k)

3D DP table storing results for all states

⚠ Quadratic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

1.2K 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

Dynamic Programming with Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler