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

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

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force (Try All Transformations)

⏱️ Time: O(26^k × n²) Space: O(n²)

This approach tries all possible combinations of character transformations up to k operations, then for each resulting string, calculates the longest palindromic subsequence. While conceptually simple, it's computationally expensive due to the exponential number of possible transformations.

Dynamic Programming with Memoization

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

This approach uses dynamic programming to solve the problem efficiently. We consider all pairs of positions and determine the minimum cost to make them match, then use this information to build the longest palindromic subsequence within our operation budget.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ 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