Skip to content

DP Other Interval DP

Table of Contents

5. Longest Palindromic Substring

class longestPalindrome:
    """Return the longest palindromic substring in s."""

    @staticmethod
    def dp(s: str) -> str:
        n = len(s)
        if n <= 1:
            return s

        start, maxLen = 0, 1

        # Init
        dp = [[0] * n for _ in range(n)]
        for i in range(n):
            dp[i][i] = 1

        # update
        for j in range(1, n):
            for i in range(j):
                if s[i] == s[j]:
                    if j - i <= 2:
                        dp[i][j] = 1
                    else:
                        dp[i][j] = dp[i + 1][j - 1]

                    if dp[i][j] and j - i + 1 > maxLen:
                        maxLen = j - i + 1
                        start = i

        return s[start : start + maxLen]

    @staticmethod
    def expand_around_center(s: str) -> str:
        def expand(left, right):
            while left >= 0 and right < len(s) and s[left] == s[right]:
                left -= 1
                right += 1
            return right - left - 1

        if len(s) <= 1:
            return s

        start, end = 0, 0
        for i in range(len(s)):
            odd = expand(i, i)
            even = expand(i, i + 1)

            maxLen = max(odd, even)
            if maxLen > end - start:
                start = i - (maxLen - 1) // 2
                end = i + maxLen // 2

        return s[start : end + 1]


if __name__ == "__main__":
    s = "babad"
    assert longestPalindrome.dp(s) in ["bab", "aba"]
    assert longestPalindrome.expand_around_center(s) in ["bab", "aba"]

647. Palindromic Substrings

"""
-   Return the number of palindromic substrings in `s`.
-   Bottom-up DP table

|  dp   |  a  |  b  |  b  |  a  |  e  |
| :---: | :-: | :-: | :-: | :-: | :-: |
| **a** |  1  |  0  |  0  |  1  |  0  |
| **b** |  0  |  1  |  1  |  0  |  0  |
| **b** |  0  |  0  |  1  |  0  |  0  |
| **a** |  0  |  0  |  0  |  1  |  0  |
| **e** |  0  |  0  |  0  |  0  |  1  |
"""


def countSubstrings(s: str) -> int:
    n = len(s)
    dp = [[0] * n for _ in range(n)]
    res = 0

    for i in range(n - 1, -1, -1):
        for j in range(i, n):
            if s[i] == s[j]:
                if j - i <= 1:
                    dp[i][j] = 1
                    res += 1
                elif dp[i + 1][j - 1]:
                    dp[i][j] = 1
                    res += 1

    return res


print(countSubstrings("abbae"))  # 7

3040. Maximum Number of Operations With the Same Score II

375. Guess Number Higher or Lower II

1130. Minimum Cost Tree From Leaf Values

  • LeetCode | 力扣

  • Tags: Array, Dynamic Programming, Stack, Greedy, Monotonic Stack

96. Unique Binary Search Trees

  • LeetCode | 力扣

  • Tags: Math, Dynamic Programming, Tree, Binary Search Tree, Binary Tree

1770. Maximum Score from Performing Multiplication Operations

1547. Minimum Cost to Cut a Stick

1039. Minimum Score Triangulation of Polygon

1000. Minimum Cost to Merge Stones

2019. The Score of Students Solving Math Expression

  • LeetCode | 力扣

  • Tags: Array, Math, String, Dynamic Programming, Stack, Memoization

3277. Maximum XOR Score Subarray Queries

87. Scramble String

312. Burst Balloons

664. Strange Printer

546. Remove Boxes

471. Encode String with Shortest Length 👑

3018. Maximum Number of Removal Queries That Can Be Processed I 👑