1216. Valid Palindrome III

Given a string s and an integer k, find out if the given string is a K-Palindrome or not.

A string is K-Palindrome if it can be transformed into a palindrome by removing at most k characters from it.

Example 1:

Input: s = "abcdeca", k = 2
Output: true
Explanation: Remove 'b' and 'e' characters.

Constraints:

• 1 <= s.length <= 1000
• s has only lowercase English letters.
• 1 <= k <= s.length

这是一道典型的dp题，用dp[][]来存储i,j两个pointer指向的string的一个char, 分别按照相等和不相等来处理即可。

最后，如果length - dp[0][length - 1] <= K, 表明可以，否则不可以。

这题和516. Longest Palindromic Subsequence 本质上是一样的。

class Solution {
    public boolean isValidPalindrome(String s, int k) {
        int n = s.length();
        int[][] f = new int[n][n];
        for (int i = 0; i < n; ++i) {
            f[i][i] = 1;
        }
        for (int i = n - 2; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                if (s.charAt(i) == s.charAt(j)) {
                    f[i][j] = f[i + 1][j - 1] + 2;
                } else {
                    f[i][j] = Math.max(f[i + 1][j], f[i][j - 1]);
                }
                if (f[i][j] + k >= n) {
                    return true;
                }
            }
        }
        return false;
    }
}

 

 这题也可以用递归

先看一下最左和最右的两个值是否相同，如果相同 i++, j--, 同时把k传下去递归

如果不相同而且k is 0, return false, othwewise,
return helper(i++, j, k -1 ) || helper(i, j--, k - 1)
这个递归明显会重复计算，所以要保存之前计算过的值，比如用map保存(i, j)是否可以在k的情况下满足palindrome的条件，最后其实还是会把问题转到dp里去。

public class KPalindrome {
    public static boolean isKPalindrome(String s, int k) {
        int[][] memo = new int[s.length()][s.length()];
        return dfs(s, 0, s.length() - 1, k, memo);
    }

    private static boolean dfs(String s, int start, int end, int k, int[][] memo) {
        // Base cases
        if (k < 0) {
            return false; // Exceeded the allowed number of deletions
        }
        if (start >= end) {
            return true; // The substring is a palindrome
        }

        // Check memoization
        if (memo[start][end] != 0) {
            return memo[start][end] == 1;
        }

        if (s.charAt(start) == s.charAt(end)) {
            // Characters match; move inward
            memo[start][end] = dfs(s, start + 1, end - 1, k, memo) ? 1 : -1;
        } else {
            // Characters don't match; try removing one character
            boolean removeStart = dfs(s, start + 1, end, k - 1, memo);
            boolean removeEnd = dfs(s, start, end - 1, k - 1, memo);
            memo[start][end] = (removeStart || removeEnd) ? 1 : -1;
        }

        return memo[start][end] == 1;
    }

    public static void main(String[] args) {
        String s = "abcdeca";
        int k = 2;
        System.out.println(isKPalindrome(s, k)); // Output: true
    }
}