华为OD机考：区间交集问题的双指针解法与Java实现

1. 项目背景与核心需求

最近在准备华为OD机考的过程中，遇到了一道关于区间交集的题目。这道题在双机位监考的C卷中出现，要求用Java实现一个高效的解决方案。作为过来人，我想把这道题的解题思路和实际编码中的注意事项分享给大家。

区间问题是算法面试中的常客，特别是在处理时间调度、资源分配等场景时非常实用。这道题的核心是给定两组区间，找出所有存在交集的区间对。听起来简单，但在限时编程环境下，如何写出既正确又高效的代码还是很有挑战性的。

2. 问题分析与算法选择

2.1 题目详细描述

给定两个区间集合A和B，每个区间表示为[start, end]。需要找出所有满足A[i]与B[j]有交集的区间对(i,j)。交集的定义是两个区间有至少一个公共整数点。

例如：
A = [[1,4], [5,8]]
B = [[3,6], [7,9]]
输出应该是 [[1,4,3,6], [5,8,3,6], [5,8,7,9]]

2.2 暴力解法与优化思路

最直观的方法是双重循环遍历所有区间对，检查是否有交集。这种方法时间复杂度O(n*m)，在区间数量较大时性能会很差。

更优的解法是利用区间已经排序的特性（题目通常保证输入有序），采用双指针法可以将时间复杂度优化到O(n+m)。这是面试官期望看到的解法。

3. 双指针算法实现详解

3.1 算法核心思想

双指针法的关键在于利用区间有序的特性，通过指针的移动跳过不可能产生交集的区间。基本步骤如下：

1. 初始化两个指针i和j，分别指向A和B的起始位置
2. 比较当前A[i]和B[j]的关系：
   • 如果有交集，记录这对区间
   • 移动end值较小的区间的指针
3. 重复直到任一集合遍历完毕

3.2 Java代码实现

java复制public List<List<Integer>> intervalIntersection(int[][] A, int[][] B) {
    List<List<Integer>> result = new ArrayList<>();
    int i = 0, j = 0;
    
    while (i < A.length && j < B.length) {
        // 计算两个区间的交集
        int start = Math.max(A[i][0], B[j][0]);
        int end = Math.min(A[i][1], B[j][1]);
        
        // 如果存在交集
        if (start <= end) {
            result.add(Arrays.asList(A[i][0], A[i][1], B[j][0], B[j][1]));
        }
        
        // 移动指针
        if (A[i][1] < B[j][1]) {
            i++;
        } else {
            j++;
        }
    }
    
    return result;
}

4. 关键细节与边界处理

4.1 交集判断的数学原理

两个区间[a1, a2]和[b1, b2]有交集的条件是：
max(a1, b1) <= min(a2, b2)

这个条件涵盖了所有可能的相交情况：

• 一个区间完全包含另一个
• 区间部分重叠
• 区间刚好相接

4.2 指针移动的逻辑

为什么总是移动end值较小的指针？因为较大的end值可能还会与下一个区间产生交集。例如：
A[i] = [1,5]
B[j] = [3,7]
B[j+1] = [6,9]
移动i指针后，A[i+1]可能与B[j]还有交集

4.3 输入处理注意事项

在实际机考中，输入可能是字符串形式，需要先解析成二维数组。例如输入可能是：
"[[1,4],[5,8]] [[3,6],[7,9]]"

解析代码示例：

java复制String[] parts = input.split(" ");
int[][] A = parseIntervals(parts[0]);
int[][] B = parseIntervals(parts[1]);

private int[][] parseIntervals(String s) {
    s = s.replaceAll("\\[|\\]", "");
    String[] nums = s.split(",");
    int[][] res = new int[nums.length/2][2];
    for (int i = 0; i < nums.length; i+=2) {
        res[i/2][0] = Integer.parseInt(nums[i]);
        res[i/2][1] = Integer.parseInt(nums[i+1]);
    }
    return res;
}

5. 性能优化与测试用例

5.1 时间复杂度分析

双指针法每个指针最多移动n或m次，因此时间复杂度是O(n+m)，比暴力解法的O(n*m)有显著提升。

空间复杂度是O(1)（不考虑输出结果的空间），因为只使用了固定数量的指针变量。

5.2 典型测试用例设计

好的测试用例应该包含：

• 常规情况：多个区间有不同形式的交集
• 边界情况：空输入、单个区间、无交集的情况
• 特殊案例：区间完全包含、刚好相接、大范围区间与小范围区间

示例测试用例：

java复制@Test
public void testIntervalIntersection() {
    // 正常情况
    int[][] A1 = {{1,4}, {5,8}};
    int[][] B1 = {{3,6}, {7,9}};
    // 预期输出: [[1,4,3,6], [5,8,3,6], [5,8,7,9]]
    
    // 无交集情况
    int[][] A2 = {{1,2}};
    int[][] B2 = {{3,4}};
    // 预期输出: []
    
    // 一个区间包含另一个
    int[][] A3 = {{1,10}};
    int[][] B3 = {{2,3}, {4,5}};
    // 预期输出: [[1,10,2,3], [1,10,4,5]]
}

6. 机考实战技巧

6.1 双机位环境下的编程

华为OD机考采用双机位监考，意味着：

1. 主屏幕会被全程录制
2. 侧方机位会监控你的操作环境
3. 切屏、打开其他程序会被检测

建议：

• 提前熟悉在线编程环境
• 准备简单的本地IDE进行练习
• 考试时全屏编程界面，避免误操作

6.2 解题步骤建议

1. 先仔细阅读题目，确保理解题意
2. 在白纸上画出区间示例，理清思路
3. 写出伪代码或算法步骤
4. 实现基础功能后再考虑优化
5. 留出时间测试边界情况

6.3 代码风格注意事项

虽然机考主要考察算法正确性，但良好的代码风格会加分：

• 有意义的变量名（不要只用i,j,k）
• 适当的空行和缩进
• 关键步骤添加简短注释
• 避免过长的函数（不超过50行）

7. 常见错误与调试技巧

7.1 典型错误模式

1. 指针移动逻辑错误：错误地移动了end值较大的指针
2. 交集判断条件错误：忽略了区间刚好相接的情况
3. 输入处理错误：没有正确解析字符串格式的输入
4. 边界条件遗漏：空输入或单区间输入处理不当

7.2 调试方法

在无法使用IDE调试的情况下：

1. 打印关键变量值：

java复制System.out.println("i="+i+" j="+j+" A[i]="+Arrays.toString(A[i])+" B[j]="+Arrays.toString(B[j]));

2. 使用小规模测试数据逐步验证
3. 检查循环终止条件是否正确
4. 验证第一个和最后一个交集是否正确处理

7.3 性能优化检查点

1. 避免在循环中创建不必要的对象
2. 使用基本类型而非包装类
3. 预计算结果列表的大小（如果可能）
4. 减少不必要的计算（如重复计算max/min）

优化后的代码示例：

java复制public List<List<Integer>> intervalIntersectionOptimized(int[][] A, int[][] B) {
    List<List<Integer>> result = new ArrayList<>(Math.min(A.length, B.length));
    int i = 0, j = 0;
    
    while (i < A.length && j < B.length) {
        int aStart = A[i][0], aEnd = A[i][1];
        int bStart = B[j][0], bEnd = B[j][1];
        
        // 计算交集
        int start = aStart > bStart ? aStart : bStart;
        int end = aEnd < bEnd ? aEnd : bEnd;
        
        if (start <= end) {
            List<Integer> intersection = new ArrayList<>(4);
            intersection.add(aStart);
            intersection.add(aEnd);
            intersection.add(bStart);
            intersection.add(bEnd);
            result.add(intersection);
        }
        
        // 移动指针
        if (aEnd < bEnd) {
            i++;
        } else {
            j++;
        }
    }
    
    return result;
}

8. 题目变种与扩展思考

8.1 常见变种题型

1. 合并所有相交区间：将结果合并为不相交的区间集合
2. 计算交集区间的总长度：统计所有交集区间的长度和
3. 最多重叠区间数：找出同时重叠区间最多的点
4. 区间插入：在已有区间集合中插入新区间并合并

8.2 实际应用场景

1. 会议室预定系统：查找可用的时间段
2. 基因序列比对：查找DNA序列的重叠区域
3. 日程安排：协调多个人的空闲时间
4. 网络带宽分配：查找资源使用冲突的时间段

8.3 进阶学习建议

1. 学习线段树(Segment Tree)数据结构，处理更复杂的区间查询
2. 研究扫描线算法(Sweep Line Algorithm)，解决二维区间问题
3. 练习LeetCode上的区间相关题目，如：
   • 56. Merge Intervals
   • 57. Insert Interval
   • 435. Non-overlapping Intervals
   • 715. Range Module

9. 个人实战经验分享

在准备华为OD机考的过程中，我发现区间类题目有几个关键点需要特别注意：

1. 画图辅助理解：在纸上画出区间的位置关系，比单纯看数字更直观
2. 测试用例要全面：特别是空区间、单点区间、完全包含等情况
3. 先保证正确性再优化：先写出清晰的代码，运行正确后再考虑性能优化
4. 注意输入格式：机考中的输入可能是字符串，需要正确解析

在双机位监考环境下，保持冷静很重要。遇到问题时：

1. 深呼吸，重新审题
2. 从简单例子入手，逐步构建解决方案
3. 如果卡住超过5分钟，先跳过做其他题
4. 最后留出时间检查边界条件

这道区间交集题目很好地考察了候选人对双指针算法的理解和应用能力。掌握这类问题的解法不仅对通过机考有帮助，在实际开发中处理时间区间、资源调度等问题时也非常实用。