LeetCode 484: Find the Longest Palindromic Subsequence with Constraints Solution in Python – A Step-by-Step Guide

What Is LeetCode 484: Find the Longest Palindromic Subsequence with Constraints?

In this imagined LeetCode 484: Find the Longest Palindromic Subsequence with Constraints, you’re given a string s and an integer k, and your task is to find the length of the longest palindromic subsequence (not necessarily contiguous) where no character appears more than k times in the subsequence. A palindromic subsequence reads the same forward and backward (e.g., "aba" in "abacde"). For example, with s = "abacde" and k = 2, the longest valid subsequence is "aba" (length 3), as 'a' appears 2 ≤ 2 times. It’s like crafting the longest mirrored thread from a string while keeping each stitch’s frequency in check.

Problem Statement

• Input: s (str)—input string; k (int)—max frequency per character.
• Output: int—length of longest palindromic subsequence with each char ≤ k times.
• Rules:
• Subsequence can be non-contiguous.
• Must be palindromic (same forward and backward).
• No character in subsequence exceeds k occurrences.

Constraints

• \( 1 \leq s.length \leq 10^4 \).
• s consists of lowercase English letters.
• \( 1 \leq k \leq 10^3 \).

Examples to Get Us Started

• Input: s = "abacde", k = 2
• Output: 3 ("aba", 'a' appears 2 ≤ 2).
• Input: s = "aaa", k = 1
• Output: 1 ("a", 'a' limited to 1).
• Input: s = "bbbaaa", k = 2
• Output: 5 ("babab", 'b' = 3 > 2 invalid, "bbabb" fits).

Understanding the Problem: Weaving the Thread

To solve LeetCode 484: Find the Longest Palindromic Subsequence with Constraints in Python, we need to find the longest subsequence of s that’s palindromic while ensuring no character exceeds k occurrences. A naive approach—generating all subsequences and checking—could be O(2^n), infeasible for n = 10^4. The key? Use dynamic programming with frequency tracking to build the solution efficiently, adapting the classic longest palindromic subsequence algorithm. We’ll explore:

• Best Solution (DP with Frequency Tracking): O(n² * 26) time, O(n² * 26) space—fast and optimal.
• Alternative Solution (Brute Force Enumeration): O(2^n) time, O(n)—simple but slow.

Let’s dive into the DP solution—it’s the weaver’s precise loom we need.

Best Solution: Dynamic Programming with Frequency Tracking

Why This Is the Best Solution

The DP with frequency tracking is the top pick because it’s O(n² * 26) time (n = string length, 26 = alphabet size) and O(n² * 26) space, efficiently finding the longest constrained palindromic subsequence by extending the classic DP approach with a frequency mask for each character. It builds a 3D table to track lengths while respecting the k limit, avoiding exponential enumeration. It’s like weaving a palindrome thread-by-thread, checking each stitch’s count—smart and scalable!

How It Works

Here’s the strategy:

• Step 1: Define DP table:
• \( dp[i][j][freq] \) = longest palindromic subsequence in s[i:j+1] with frequency vector \( freq \) (26 chars, each ≤ k).
• Step 2: Base cases:
• Single char: length 1, freq[char] = 1.
• Empty: length 0, freq all 0.
• Step 3: Recurrence:
• If s[i] = s[j] and freq[s[i]] < k:
• \( dp[i][j][freq] = 2 + dp[i+1][j-1][freq + 1 for s[i]] \).
• Else: max(\( dp[i+1][j][freq] \), \( dp[i][j-1][freq] \)).
• Step 4: Return max length from \( dp[0][n-1] \) over valid freqs.
• Why It Works:
• DP builds palindromes bottom-up.
• Frequency tracking ensures constraint compliance.

Step-by-Step Example

Example: s = "abac", k = 2

• n = 4, init \( dp[4][4][26] \).
• Base:
• \( dp[0][0][a=1] = 1 \), \( dp[1][1][b=1] = 1 \), etc.
• Len 2:
• "ab": \( dp[0][1] = 1 \) (max of "a", "b").
• "ba": \( dp[1][2] = 1 \).
• "ac": \( dp[2][3] = 1 \).
• Len 3:
• "aba": \( dp[0][2][a=2,b=1] = 3 \) (a ≤ 2), else 1.
• "bac": \( dp[1][3] = 1 \).
• Len 4:
• "abac": \( dp[0][3] = 3 \) (max of "aba", others).
• Result: 3 ("aba").

Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down clearly (simplified with dict for clarity):

Copy codeclass Solution:
    def longestPalindromeSubseqWithConstraint(self, s: str, k: int) -> int:
        n = len(s)
        # dp[i][j] = {freq: length}
        dp = [[{} for _ in range(n)] for _ in range(n)]

        # Step 1: Base cases
        for i in range(n):
            freq = [0] * 26
            freq[ord(s[i]) - ord('a')] = 1
            dp[i][i][tuple(freq)] = 1

        # Step 2: Fill DP table
        for length in range(2, n + 1):
            for i in range(n - length + 1):
                j = i + length - 1
                # Try all previous states
                for freq_i, len_i in dp[i + 1][j].items():
                    dp[i][j][freq_i] = max(dp[i][j].get(freq_i, 0), len_i)
                for freq_j, len_j in dp[i][j - 1].items():
                    dp[i][j][freq_j] = max(dp[i][j].get(freq_j, 0), len_j)

                if s[i] == s[j]:
                    for freq_mid, len_mid in dp[i + 1][j - 1].items():
                        new_freq = list(freq_mid)
                        char_idx = ord(s[i]) - ord('a')
                        if new_freq[char_idx] + 2 <= k:
                            new_freq[char_idx] += 2
                            dp[i][j][tuple(new_freq)] = max(dp[i][j].get(tuple(new_freq), 0), len_mid + 2)

        # Step 3: Find max length
        max_len = 0
        for freq, length in dp[0][n - 1].items():
            max_len = max(max_len, length)
        return max_len

# Example usage
s = "abacde"
k = 2
solution = Solution()
print(solution.longestPalindromeSubseqWithConstraint(s, k))  # Output: 3

• Line 5-6: Init 3D DP with dicts for frequency states.
• Line 9-12: Base case: single char, freq = 1.
• Line 15-29: Build DP:
• For each length and i,j pair.
• Copy subproblems (skip i or j).
• If s[i] = s[j], try adding both if freq allows.
• Line 32-35: Max length over valid freqs.
• Time Complexity: O(n² * 26)—n² states, 26 freq checks.
• Space Complexity: O(n² * 26)—DP table.

It’s like a palindrome-weaving loom!

Alternative Solution: Brute Force Enumeration

Why an Alternative Approach?

The brute force enumeration—O(2^n) time, O(n) space—generates all subsequences, checks if they’re palindromic and satisfy the k constraint, and tracks the longest. It’s slow but intuitive, like trying every thread combination by hand. Good for small n or learning!

How It Works

• Step 1: Generate all subsequences (bitmask).
• Step 2: Check each for palindrome and freq ≤ k.
• Step 3: Track max length.
• Step 4: Return result.

Step-by-Step Example

Example: s = "aba", k = 2

• Subsequences: "", "a", "b", "a", "ab", "aa", "ba", "aba".
• Palindromes: "", "a", "b", "a", "aa", "aba".
• Valid: "a" (1), "b" (1), "a" (1), "aa" (2 ≤ 2), "aba" (a=2 ≤ 2).
• Max: 3 ("aba").
• Result: 3.

Code for Brute Force

Copy codeclass Solution:
    def longestPalindromeSubseqWithConstraint(self, s: str, k: int) -> int:
        def is_palindrome(sub):
            return sub == sub[::-1]

        def check_freq(sub, k):
            freq = {}
            for c in sub:
                freq[c] = freq.get(c, 0) + 1
                if freq[c] > k:
                    return False
            return True

        n = len(s)
        max_len = 0
        for mask in range(1 << n):
            sub = ""
            for i in range(n):
                if mask & (1 << i):
                    sub += s[i]
            if is_palindrome(sub) and check_freq(sub, k):
                max_len = max(max_len, len(sub))
        return max_len

• Line 3-12: Helper functions for palindrome and freq checks.
• Line 15-22: Enumerate subsequences, check validity, update max.
• Time Complexity: O(2^n)—exponential subsequences.
• Space Complexity: O(n)—subsequence string.

It’s a slow thread counter!

Comparing the Two Solutions

• DP with Frequency Tracking (Best):
• Pros: O(n² * 26), fast, scalable.
• Cons: O(n² * 26) space, complex.
• Brute Force (Alternative):
• Pros: O(2^n), simple.
• Cons: Impractical for large n.

DP wins for efficiency.

Edge Cases and Examples

• Input: s="a", k=1 → 1.
• Input: s="aaa", k=3 → 3.
• Input: s="", k=2 → 0 (assumed).

DP handles all well.

Complexity Recap

• DP: Time O(n² * 26), Space O(n² * 26).
• Brute Force: Time O(2^n), Space O(n).

DP’s the champ.

Key Takeaways

• DP: Track with freq.
• Brute Force: Test all combos.
• Python Tip: DP weaves fast—see [Python Basics](/python/basics).

Final Thoughts: Weave That Palindrome

LeetCode 484: Find the Longest Palindromic Subsequence with Constraints in Python is a string-weaving adventure. DP with frequency tracking is your fast loom, while brute force is a slow needle. Want more string challenges? Try LeetCode 516: Longest Palindromic Subsequence or LeetCode 5: Longest Palindromic Substring. Ready to thread some palindromes? Head to Solve LeetCode 484 on LeetCode (if available) and weave it today—your coding skills are thread-ready!