Valid Palindrome III - Practice Coding Problems

Valid Palindrome III - Problem

Valid Palindrome III is a challenging string manipulation problem that tests your dynamic programming skills.

Given a string s and an integer k, determine if s can become a palindrome by removing at most k characters. A palindrome reads the same forwards and backwards (like "racecar" or "madam").

For example, if s = "abcdeca" and k = 2, we can remove 'b' and 'd' to get "aceca", which is a palindrome. Therefore, the answer is true.

Key insight: This problem is equivalent to finding the longest palindromic subsequence in the string. If the length of the longest palindromic subsequence is at least n - k (where n is the string length), then we can remove at most k characters to form a palindrome.

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: We can remove 'b' and 'd' to get "aceca", which is a palindrome. Only 2 characters removed, which is ≤ k.

example_2.py — Impossible Case

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

› Output: false

💡 Note: The longest palindromic subsequence is "ababa" (length 5). We need to remove 8-5=3 characters, but k=1, so it's impossible.

example_3.py — Edge Case

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

› Output: true

💡 Note: A single character is already a palindrome, no removals needed.

Visualization

Tap to expand

Understanding the Visualization

Identify Core Story

Find the longest palindromic subsequence - this is your core narrative

Count Damaged Pages

Characters not in LPS are like damaged pages that must be removed

Check Budget

If damaged pages ≤ k, you can afford the restoration

Make Decision

Return true if restoration is within budget

Key Takeaway

🎯 Key Insight: Transform the problem into finding the Longest Palindromic Subsequence. The number of characters to remove equals string length minus LPS length. This reduces a complex problem into a well-known DP pattern.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We fill an n×n DP table, each cell taking O(1) time

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n×n, can be optimized to O(n) space

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
1 ≤ k ≤ s.length

Asked in

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

The optimal approach uses dynamic programming to find the Longest Palindromic Subsequence (LPS). The key insight is that if we can find a palindromic subsequence of length L in a string of length N, we need to remove exactly N-L characters. Therefore, the problem reduces to: find LPS and check if N-LPS ≤ k. Time complexity: O(n²), Space complexity: O(n²).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Longest Palindromic Subsequence)	O(n²)	O(n²)	Find longest palindromic subsequence, then check if remaining removals ≤ k

Dynamic Programming (Longest Palindromic Subsequence) — Algorithm Steps

Create a 2D DP table where dp[i][j] represents LPS length in substring s[i:j+1]
Fill the table: if s[i] == s[j], dp[i][j] = dp[i+1][j-1] + 2
Otherwise, dp[i][j] = max(dp[i+1][j], dp[i][j-1])
Check if n - dp[0][n-1] ≤ k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set diagonal to 1 (single characters)

Fill Length 2

Check pairs of adjacent characters

Expand

Build longer palindromes from shorter ones

Result

dp[0][n-1] gives longest palindromic subsequence

Code -

solution.c — C

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

int max(int a, int b) {
    return (a > b) ? a : b;
}

int longestPalindromicSubsequence(char* s) {
    int n = strlen(s);
    int** dp = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        dp[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Every single character is a palindrome of length 1
    for (int i = 0; i < n; i++) {
        dp[i][i] = 1;
    }
    
    // Fill the table for substrings of length 2 to n
    for (int length = 2; length <= n; length++) {
        for (int i = 0; i <= n - length; i++) {
            int j = i + length - 1;
            
            if (s[i] == s[j]) {
                if (length == 2) {
                    dp[i][j] = 2;
                } else {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }
            } else {
                dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
            }
        }
    }
    
    int result = dp[0][n - 1];
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(dp[i]);
    }
    free(dp);
    
    return result;
}

bool isKPalindrome(char* s, int k) {
    int n = strlen(s);
    int lpsLength = longestPalindromicSubsequence(s);
    int removalsNeeded = n - lpsLength;
    return removalsNeeded <= k;
}

int main() {
    char s[] = "abcdeca";
    int k = 2;
    printf("%s\n", isKPalindrome(s, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We fill an n×n DP table, each cell taking O(1) time

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table of size n×n, can be optimized to O(n) space

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
1 ≤ k ≤ s.length

28.4K Views

Medium-High Frequency

~25 min Avg. Time

890 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

Dynamic Programming (Longest Palindromic Subsequence) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler