东华OJ第66-70题解析：动态规划与图论实战

1. 项目背景与需求解析

东华OJ作为国内知名的在线判题系统，一直是计算机专业学生和编程爱好者提升算法能力的重要平台。最近在刷东华OJ第66-70题时，我发现这几道题目虽然难度评级不高，但涉及的知识点组合和边界条件处理非常考验编程基本功。特别是对于刚接触算法竞赛的同学来说，这几道题容易在细节处栽跟头。

这五道题主要考察了以下几个核心知识点：

• 字符串处理与正则表达式应用
• 动态规划的基本实现
• 图论中的最短路径问题
• 数学中的素数判断与质因数分解
• 递归与回溯算法的实际应用

提示：东华OJ的测试用例往往包含大量边界情况，建议在本地测试时自行构造极端数据，比如空输入、超大数值、特殊字符等情况。

2. 题目详解与解题思路

2.1 第66题：字符串模式匹配

这道题要求实现一个支持通配符的字符串匹配功能。与普通的字符串查找不同，题目中的模式串可能包含"?"和"*"两种特殊字符：

• "?" 匹配任意单个字符
• "*" 匹配零个或多个任意字符

动态规划解法：

python复制def isMatch(s: str, p: str) -> bool:
    m, n = len(s), len(p)
    dp = [[False] * (n + 1) for _ in range(m + 1)]
    dp[0][0] = True
    
    for j in range(1, n + 1):
        if p[j-1] == '*':
            dp[0][j] = dp[0][j-1]
    
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if p[j-1] == s[i-1] or p[j-1] == '?':
                dp[i][j] = dp[i-1][j-1]
            elif p[j-1] == '*':
                dp[i][j] = dp[i][j-1] or dp[i-1][j]
    
    return dp[m][n]

注意事项：

1. 空字符串与空模式应该返回True
2. 连续的""可以简化为单个""提高效率
3. 对于超长字符串，需要考虑滚动数组优化空间复杂度

2.2 第67题：矩阵中的最长递增路径

这道题要求在一个整数矩阵中找到最长的递增路径长度，移动方向仅限于上下左右。例如：

code复制输入：matrix = [
  [9,9,4],
  [6,6,8],
  [2,1,1]
]
输出：4 （最长路径是1→2→6→9）

记忆化DFS解法：

python复制def longestIncreasingPath(matrix):
    if not matrix: return 0
    m, n = len(matrix), len(matrix[0])
    memo = [[0]*n for _ in range(m)]
    max_len = 0
    
    def dfs(i, j):
        if memo[i][j]: return memo[i][j]
        val = matrix[i][j]
        memo[i][j] = 1 + max(
            dfs(i-1,j) if i>0 and matrix[i-1][j]>val else 0,
            dfs(i+1,j) if i<m-1 and matrix[i+1][j]>val else 0,
            dfs(i,j-1) if j>0 and matrix[i][j-1]>val else 0,
            dfs(i,j+1) if j<n-1 and matrix[i][j+1]>val else 0
        )
        return memo[i][j]
    
    for i in range(m):
        for j in range(n):
            max_len = max(max_len, dfs(i,j))
    
    return max_len

优化技巧：

1. 使用记忆化存储避免重复计算
2. 可以预先对所有单元格按值排序，然后按从大到小的顺序处理
3. 对于特别大的矩阵，可以考虑并行处理不同区域

3. 核心算法实现与优化

3.1 第68题：课程表问题（拓扑排序）

这道题是经典的课程安排问题，给定课程总量和先修关系，判断是否能够完成所有课程。

Kahn算法实现：

python复制def canFinish(numCourses, prerequisites):
    adj = [[] for _ in range(numCourses)]
    indegree = [0] * numCourses
    
    for pair in prerequisites:
        adj[pair[1]].append(pair[0])
        indegree[pair[0]] += 1
    
    queue = []
    for i in range(numCourses):
        if indegree[i] == 0:
            queue.append(i)
    
    count = 0
    while queue:
        current = queue.pop(0)
        count += 1
        
        for neighbor in adj[current]:
            indegree[neighbor] -= 1
            if indegree[neighbor] == 0:
                queue.append(neighbor)
    
    return count == numCourses

性能对比：

3.2 第69题：数据流的中位数

这道题要求设计一个数据结构，能够高效地获取数据流的中位数。

双堆解法：

python复制import heapq

class MedianFinder:
    def __init__(self):
        self.max_heap = []  # 存储较小的一半
        self.min_heap = []  # 存储较大的一半

    def addNum(self, num):
        if not self.max_heap or num <= -self.max_heap[0]:
            heapq.heappush(self.max_heap, -num)
        else:
            heapq.heappush(self.min_heap, num)
        
        # 平衡两个堆的大小
        if len(self.max_heap) > len(self.min_heap) + 1:
            heapq.heappush(self.min_heap, -heapq.heappop(self.max_heap))
        elif len(self.min_heap) > len(self.max_heap):
            heapq.heappush(self.max_heap, -heapq.heappop(self.min_heap))

    def findMedian(self):
        if len(self.max_heap) == len(self.min_heap):
            return (-self.max_heap[0] + self.min_heap[0]) / 2
        else:
            return -self.max_heap[0]

复杂度分析：

• 插入操作：O(logN)
• 查询中位数：O(1)
• 空间复杂度：O(N)

4. 常见错误与调试技巧

4.1 第70题：编辑距离问题

这道题要求计算将一个单词转换成另一个单词所需的最少操作次数（插入、删除、替换）。

典型错误案例：

1. 初始化DP数组时行列大小不对应
2. 没有正确处理空字符串的情况
3. 替换操作的cost计算错误

正确的DP解法：

python复制def minDistance(word1, word2):
    m, n = len(word1), len(word2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j
    
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if word1[i-1] == word2[j-1]:
                dp[i][j] = dp[i-1][j-1]
            else:
                dp[i][j] = 1 + min(
                    dp[i-1][j],    # 删除
                    dp[i][j-1],    # 插入
                    dp[i-1][j-1]   # 替换
                )
    
    return dp[m][n]

调试技巧：

1. 打印DP表格可视化中间结果
2. 对于短字符串，可以手动计算预期结果
3. 特别注意边界条件：空字符串、完全相同字符串、完全不相同字符串

5. 实战经验与性能优化

在实际解题过程中，我发现东华OJ的测试用例有以下几个特点：

1. 时间限制通常比较严格，需要选择最优算法
2. 内存限制相对宽松，可以适当使用空间换时间
3. 边界测试用例占比较大，需要特别注意特殊情况的处理

通用优化策略：

1. 输入输出优化：对于Python可以使用sys.stdin.readline加速输入
2. 预处理数据：如有可能，预先计算并存储中间结果
3. 剪枝策略：在回溯或DFS中尽早终止不可能的分支
4. 使用更高效的数据结构：比如用collections.deque代替list实现队列

对于第66-70题，经过多次提交验证，我总结出以下性能关键点：

在本地测试时，建议构建如下测试用例：

1. 最大规模测试：按照题目给出的上限构造数据
2. 极端值测试：0值、负值、超大值等
3. 随机测试：使用随机生成器构造多样化的测试用例

对于想要系统提升算法能力的同学，我建议按照以下路线图练习：

1. 先掌握每种题型的标准解法
2. 然后尝试不同的解法并比较性能
3. 最后挑战更高难度的变形题目

刷题时养成的好习惯：

1. 每道题至少尝试两种解法
2. 记录每种解法的时空复杂度
3. 分析最优解法的适用条件和限制
4. 整理常见错误和调试方法

最后分享一个实用技巧：在解决动态规划问题时，先用小例子手动填写DP表格，确保完全理解状态转移方程后再开始编码，这样可以避免很多低级错误。对于图论问题，在纸上画出样例图并标注算法执行过程也非常有帮助。