东华大学考研机试OJ系统刷题指南：动态规划与字符串处理

1. 项目背景与价值解析

作为一名计算机专业考研过来人，我深知东华大学复试机试环节的OJ系统对考生的重要性。这个"每日3题打卡"系列源于我去年备考时的真实训练记录，通过持续刷题保持编程手感，同时建立完整的错题复盘体系。112~114这三天的题目组合特别具有代表性，涵盖了动态规划、字符串处理和二叉树三大高频考点。

在复试冲刺阶段，很多同学容易陷入两个极端：要么盲目追求刷题数量，要么死磕少数难题。这个打卡计划的价值在于：

• 保持每日稳定的算法思维训练节奏
• 通过固定题量避免疲劳作战
• 每道题都要求写详细解题报告，形成可追溯的成长轨迹

2. 题目深度解析与实现方案

2.1 动态规划经典问题（Day112）

典型例题：最小路径和问题

python复制def minPathSum(grid):
    m, n = len(grid), len(grid[0])
    dp = [[0]*n for _ 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], dp[i][j-1]) + grid[i][j]
    
    return dp[-1][-1]

关键训练点：

1. 识别DP适用场景：问题具有最优子结构特性
2. 状态定义技巧：dp[i][j]表示到达(i,j)时的最小和
3. 边界条件处理：首行/首列的特殊初始化

注意：东华OJ的测试用例常包含m=1或n=1的边界情况，必须单独验证

2.2 字符串模式匹配（Day113）

KMP算法实现要点：

python复制def build_lps(pattern):
    lps = [0] * len(pattern)
    length = 0
    i = 1
    while i < len(pattern):
        if pattern[i] == pattern[length]:
            length += 1
            lps[i] = length
            i += 1
        else:
            if length != 0:
                length = lps[length-1]
            else:
                lps[i] = 0
                i += 1
    return lps

def kmp_search(text, pattern):
    lps = build_lps(pattern)
    i = j = 0
    while i < len(text):
        if text[i] == pattern[j]:
            i += 1
            j += 1
            if j == len(pattern):
                return i - j
        else:
            if j != 0:
                j = lps[j-1]
            else:
                i += 1
    return -1

易错点分析：

1. LPS数组构建时length的回退逻辑
2. 主循环中匹配失败时的跳转处理
3. 测试时需要包含重复子串的情况（如"aabaaab"）

2.3 二叉树遍历变种（Day114）

锯齿形层次遍历实现：

python复制from collections import deque

def zigzagLevelOrder(root):
    if not root: return []
    queue = deque([root])
    res = []
    level = 0
    
    while queue:
        size = len(queue)
        current_level = []
        
        for _ in range(size):
            node = queue.popleft()
            current_level.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        
        if level % 2 == 1:
            current_level = current_level[::-1]
        res.append(current_level)
        level += 1
    
    return res

技巧提示：

1. 使用双端队列提高反转效率
2. level计数器的奇偶判断比bool标记更不易出错
3. 东华OJ的二叉树输入常为层序序列，需要提前准备建树工具函数

3. 训练方法论与效率提升

3.1 计时训练法

我采用的训练流程：

1. 设置25分钟倒计时完成1题
2. 时间到立即停止，记录完成进度
3. 分析未完成原因：
   • 算法选择不当
   • 编码实现卡壳
   • 边界条件遗漏

3.2 错题分类体系

建立错误类型标签：

1. 逻辑错误（算法设计缺陷）
2. 实现错误（编码过程失误）
3. 优化不足（时间/空间复杂度不达标）
4. 理解偏差（题意理解错误）

3.3 调试技巧

东华OJ特有注意事项：

1. 使用标准输入输出（sys.stdin读取大数据量）
2. 避免使用全局变量（多测试用例时会残留状态）
3. 提前准备常用模板（快速IO、建树工具类等）

4. 典型问题实录与解决方案

4.1 内存超限问题

案例：使用递归实现DP导致栈溢出

python复制# 错误示范
def dfs(i, j):
    if i == 0 and j == 0:
        return grid[0][0]
    if i < 0 or j < 0:
        return float('inf')
    return min(dfs(i-1,j), dfs(i,j-1)) + grid[i][j]

改进方案：

1. 改用迭代法实现
2. 滚动数组优化空间
3. 使用lru_cache装饰器（Python特定解法）

4.2 时间优化技巧

字符串匹配的Rabin-Karp算法实现：

python复制def rabin_karp(text, pattern):
    d = 256  # 字符集大小
    q = 9997  # 大素数
    m, n = len(pattern), len(text)
    h = pow(d, m-1) % q
    p = t = 0
    
    # 计算初始哈希
    for i in range(m):
        p = (d*p + ord(pattern[i])) % q
        t = (d*t + ord(text[i])) % q
    
    for i in range(n-m+1):
        if p == t:
            if text[i:i+m] == pattern:
                return i
        if i < n-m:
            t = (d*(t-ord(text[i])*h) + ord(text[i+m])) % q
            if t < 0:
                t += q
    return -1

4.3 输入输出处理

东华OJ常见输入格式处理：

python复制import sys

def process_input():
    # 多测试用例带空行分隔的情况
    data = sys.stdin.read().split('\n')
    idx = 0
    while idx < len(data):
        if not data[idx].strip():
            idx += 1
            continue
        n = int(data[idx])
        matrix = []
        for _ in range(n):
            idx += 1
            matrix.append(list(map(int, data[idx].split())))
        yield matrix
        idx += 1

5. 备考路线规划建议

5.1 阶段划分

1. 基础巩固期（30天）：

   • 每日3题（线性表/树/图各1）
   • 重点训练标准模板实现

2. 专题突破期（20天）：

   • 按算法类型集中训练
   • 制作错题本记录典型case

3. 模拟冲刺期（10天）：

   • 全真模拟考试环境
   • 重点练习调试技巧

5.2 资源推荐

东华特色题库：

1. 历年复试真题（重点研究近3年）
2. 动态规划专项（背包问题变种多）
3. 字符串处理（KMP/字典树高频）

5.3 临场策略

1. 题目选择顺序：

   • 先做通过率50%以上的题目
   • 最后攻坚30%以下的难题

2. 时间分配建议：

   • 读题分析：5分钟/题
   • 编码实现：15分钟/题
   • 调试测试：10分钟/题

这套打卡方法让我在去年复试中取得了机试满分，关键不在于刷题数量，而在于建立系统的解题思维框架。现在回头看112~114这三天的记录，发现当时纠结的DP状态定义问题，后来成了我最擅长的题型之一。建议每刷完20题就做一次专题总结，会发现很多题目本质上是相同解法的不同表现形式。