62. 不同路径

一个机器人位于一个 m $\ast$ n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角。

问总共有多少条不同的路径？

示例 1：

输入：m = 3, n = 7
输出：28

Solution

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[1] * n for _ in range(m)]
        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        return dp[m - 1][n - 1]

64. 最小路径和

给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

示例：

输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
输出：7
解释：因为路径 1→3→1→1→1 的总和最小。

Solution

5. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例：
输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

Solution

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        if n < 2:
            return s

        # 初始化动态规划的表
        dp = [[False] * n for _ in range(n)]
        start = 0  # 记录最长回文子串的起始位置
        max_len = 1  # 记录最长回文子串的长度

        # 初始化长度为1的所有子串为回文
        for i in range(n):
            dp[i][i] = True

        # 动态规划填表
        for j in range(1, n):
            for i in range(0, j):
                if s[i] == s[j]:
                    if j - i < 3:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i + 1][j - 1]

                # 更新最长回文子串的信息
                if dp[i][j]:
                    if j - i + 1 > max_len:
                        max_len = j - i + 1
                        start = i

        return s[start:start + max_len]

使用中心扩展算法的基本思想是考虑每个字符作为回文的中心，并向外扩展。需要注意的是，回文可以是奇数长度或偶数长度。例如，“aba"是一个奇数长度的回文，中心是’b’；而"abba"是一个偶数长度的回文，中心是"bb”。

我们可以遍历字符串的每一个字符，并对每个字符尝试奇数和偶数的扩展，找到最长的回文子串。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        # 特殊情况，空字符串或长度为1的字符串直接返回
        if len(s) < 2:
            return s
        
        start = 0  # 最长回文子串的起始位置
        max_len = 1  # 最长回文子串的长度

        for i in range(len(s)):
            # 奇数长度的回文检查
            l, r = i, i
            while l >= 0 and r < len(s) and s[l] == s[r]:
                l -= 1
                r += 1
            if r - l - 1 > max_len:
                max_len = r - l - 1
                start = l + 1

            # 偶数长度的回文检查
            l, r = i, i + 1
            while l >= 0 and r < len(s) and s[l] == s[r]:
                l -= 1
                r += 1
            if r - l - 1 > max_len:
                max_len = r - l - 1
                start = l + 1

        return s[start: start + max_len]