动态规划与栈应用：最长有效括号与路径问题解析

Dyingalive

1. 最长有效括号问题解析

1.1 问题背景与核心思路

最长有效括号是字符串处理中的经典问题，要求我们找出给定字符串中最长的有效括号子串的长度。有效括号字符串需要满足每个左括号都能找到对应的右括号，并且括号嵌套关系正确。

我最初解决这个问题时，尝试过暴力解法——枚举所有可能的子串并验证其有效性。这种方法虽然直观，但时间复杂度高达O(n³)，显然不适合处理较长的输入。经过思考，我发现可以利用栈这种数据结构来优化解法。

栈的特性完美匹配了括号匹配的需求：后进先出的特性可以确保最近遇到的左括号能够优先匹配右括号。具体实现时，我们不仅需要记录括号本身，还需要记录它们在字符串中的位置信息，这样才能准确计算有效子串的长度。

1.2 详细解法与代码实现

在实现过程中，我设置了一个初始值为-1的栈底元素作为哨兵节点。这个技巧非常重要，它帮助我们处理边界情况，特别是当有效子串从字符串开头开始时。

python复制class Solution:
    def longestValidParentheses(self, s: str) -> int:
        stack = [-1]  # 虚拟哨兵，以这个点为界
        result = 0

        for i, ch in enumerate(s):
            if ch == '(':
                stack.append(i)
            elif len(stack) > 1:  # 除哨兵外元素非空
                stack.pop()
                result = max(result, i - stack[-1])
            else:
                stack[0] = i

        return result

这段代码的核心逻辑是：

遇到左括号时，将其索引压入栈
遇到右括号时，如果栈中有对应的左括号（栈长度>1），则弹出栈顶元素并计算当前有效长度
如果栈中没有对应左括号（只有哨兵），则更新哨兵位置

1.3 复杂度分析与优化空间

这个算法的时间复杂度是O(n)，因为我们只需要遍历字符串一次。空间复杂度也是O(n)，最坏情况下需要存储所有左括号的索引。

在实际测试中，我发现这个解法已经相当高效。不过，对于特别长的字符串，可以考虑使用双指针法进一步优化空间复杂度到O(1)，但实现起来会更加复杂，且需要考虑更多边界情况。

2. 不同路径问题解析

2.1 问题理解与动态规划思路

不同路径问题要求计算从网格左上角到右下角的所有可能路径数，每次只能向右或向下移动。这是一个典型的动态规划问题，因为当前格子的路径数取决于其上方和左侧格子的路径数。

我最初尝试用递归解决这个问题，但很快就遇到了性能问题。对于较大的网格（比如19x13），递归解法会因为重复计算而变得极其缓慢。这促使我转向动态规划解法。

2.2 动态规划实现细节

python复制class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        dp = [[0] * n for i in range(m)]

        for i in range(m):
            dp[i][0] = 1

        for j in range(n):
            dp[0][j] = 1

        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]

实现中的几个关键点：

初始化第一行和第一列为1，因为沿着网格边缘只有一条路径
使用双重循环填充dp数组，每个格子的值等于上方格子值加左侧格子值
最终结果是右下角格子的值

2.3 数学解法与组合数

这个问题还可以用组合数学的方法解决。从起点到终点需要移动(m-1)+(n-1)步，其中(m-1)步向下，(n-1)步向右。因此路径总数等于从(m+n-2)步中选择(m-1)步向下的组合数。

虽然数学解法更简洁，但在实际编程中计算大数组合数可能会遇到数值溢出问题，需要特别注意。动态规划解法虽然空间复杂度较高，但实现起来更直观可靠。

3. 最小路径和问题解析

3.1 问题分析与解法选择

最小路径和问题要求找到从网格左上角到右下角的路径，使得路径上的数字总和最小。这看起来与不同路径问题相似，但需要计算的是最小值而非总数。

我尝试将不同路径问题的解法进行调整，发现只需要将递推公式中的加法改为取最小值操作即可。这说明很多动态规划问题虽然具体要求不同，但基本思路是相通的。

3.2 代码实现与优化

python复制class Solution:
    def minPathSum(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])

        dp = [[0] * n for i in range(m)]
        dp[0][0] = grid[0][0]

        for i in range(1, m):
            dp[i][0] = dp[i - 1][0] + grid[i][0]

        for j in range(1, n):
            dp[0][j] = dp[0][j - 1] + grid[0][j]

        for i in range(1, m):
            for j in range(1, n):
                dp[i][j] = min(dp[i - 1][j] + grid[i][j], 
                              dp[i][j - 1] + grid[i][j])

        return dp[m - 1][n - 1]