OJ104/OJ105/OJ106算法题解析与优化技巧

1. OJ104/OJ105/OJ106题目解析与实战攻略

这三个编号同属一个经典算法题库的连续题目，通常考察程序员对基础数据结构和算法的掌握程度。虽然原描述信息有限，但根据OJ（Online Judge）系统的常规出题规律，这类连续编号题目往往存在递进关系或考察相似知识点。以下是针对这三个题目的通用解题框架：

1.1 题目类型预判

根据常见OJ题库的编排逻辑：

• OJ104：大概率考察线性数据结构（数组/链表）的基础操作
• OJ105：可能涉及简单排序或查找算法
• OJ106：通常会引入递归或初级动态规划思想

提示：实际解题前务必仔细阅读题目描述，这种预判仅适用于无具体描述时的应急准备

1.2 通用解题四步法

1. 输入输出分析：确定数据输入格式（如多组测试用例）和输出要求（精度、格式等）
2. 边界条件识别：特别关注空输入、极值、非法输入等特殊情况
3. 复杂度估算：根据数据规模选择合适算法（如n≤1e5时O(nlogn)算法通常可行）
4. 测试用例设计：至少包含正常case、边界case和极端case三类

2. OJ104典型解法与优化技巧

假设该题是经典的"数组去重"问题（常见于入门题库），这里给出两种实现方案：

2.1 哈希表解法（时间复杂度O(n)）

python复制def remove_duplicates(nums):
    seen = {}
    index = 0
    for num in nums:
        if num not in seen:
            seen[num] = True
            nums[index] = num
            index += 1
    return index

优化点：

• 使用字典查询（平均O(1)）替代列表遍历（O(n)）
• 原地修改数组减少空间占用

2.2 双指针解法（空间复杂度O(1)）

python复制def remove_duplicates(nums):
    if not nums:
        return 0
    
    slow = 0
    for fast in range(1, len(nums)):
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    return slow + 1

适用场景：

• 当题目要求空间复杂度O(1)时
• 输入数组已排序的情况（未排序时需要先排序）

3. OJ105常见考察方向与实现

假设该题涉及基础排序算法，以下是不同场景下的选择策略：

3.1 算法选择矩阵

3.2 快速排序的工程实现要点

python复制def quick_sort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quick_sort(arr, low, pi-1)
        quick_sort(arr, pi+1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i+1

避坑指南：

1. 递归深度问题：当数据基本有序时可能栈溢出，可改用尾递归优化
2. 基准值选择：固定选最后元素在有序数据时性能退化，建议随机选择
3. 小数组优化：当子数组长度<15时可切换为插入排序

4. OJ106进阶问题解析

假设该题是经典的爬楼梯问题（动态规划入门题），展示不同解法的演进：

4.1 暴力递归解法

python复制def climb_stairs(n):
    if n == 1: return 1
    if n == 2: return 2
    return climb_stairs(n-1) + climb_stairs(n-2)

问题：存在大量重复计算，时间复杂度O(2^n)

4.2 记忆化搜索优化

python复制memo = {}
def climb_stairs(n):
    if n in memo: return memo[n]
    if n == 1: return 1
    if n == 2: return 2
    memo[n] = climb_stairs(n-1) + climb_stairs(n-2)
    return memo[n]

优化后：时间复杂度O(n)，空间复杂度O(n)

4.3 动态规划终极解法

python复制def climb_stairs(n):
    if n == 1: return 1
    dp = [0]*(n+1)
    dp[1], dp[2] = 1, 2
    for i in range(3, n+1):
        dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

进一步优化空间：

python复制def climb_stairs(n):
    if n == 1: return 1
    a, b = 1, 2
    for _ in range(3, n+1):
        a, b = b, a+b
    return b

最终达到：时间复杂度O(n)，空间复杂度O(1)

5. OJ系统实战技巧

5.1 输入输出加速技巧

• C++使用ios::sync_with_stdio(false)关闭同步
• Python使用sys.stdin.readline替代input
• Java使用BufferedReader而非Scanner

5.2 常见WA（Wrong Answer）原因排查

1. 边界条件：0值、最大值、最小值等特殊情况
2. 数据类型：整数溢出、浮点精度问题
3. 多组输入：未正确初始化循环变量
4. 输出格式：行末空格、换行符缺失

5.3 时间复杂度估算速查表

6. 算法竞赛进阶路线

对于想系统提升算法能力的开发者，建议按以下顺序攻克：

1. 基础数据结构：数组/链表/栈/队列/哈希表
2. 初级算法：二分查找/简单排序/递归
3. 中级算法：DFS/BFS/贪心/基础DP
4. 高级算法：树状数组/线段树/网络流
5. 专项突破：字符串匹配/计算几何/数论

每个阶段建议完成30-50道对应难度的OJ题目，建立自己的代码模板库。我个人的经验是，准备一个分类整理的代码片段库，可以大幅提高解题效率。比如把常见的并查集、快速幂、Dijkstra等算法写成可复用的模板函数。