算法实战：五大经典数组与矩阵问题深度解析

在算法学习和面试准备中，数组和矩阵相关的问题占据了重要地位。本文将深入解析五个经典的算法问题，涵盖集合操作、矩阵变换、区间统计等多个重要概念，每个问题都配有详细的示例、多种解法和实用技巧。

1. 两个数组的交集 II

问题描述

给定两个整数数组，返回它们的交集，结果中每个元素出现的次数应与元素在两个数组中都出现的次数一致（取较小值），不考虑输出结果的顺序。

示例说明：

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2,2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出：[4,9]

解法一：哈希表法

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        // 总是对较小的数组构建哈希表以减少空间复杂度
        if (nums1.length > nums2.length) {
            return intersect(nums2, nums1);
        }
        
        Map<Integer, Integer> map = new HashMap<>();
        List<Integer> result = new ArrayList<>();
        
        // 统计第一个数组中每个数字的出现次数
        for (int num : nums1) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        
        // 遍历第二个数组，找到交集
        for (int num : nums2) {
            int count = map.getOrDefault(num, 0);
            if (count > 0) {
                result.add(num);
                map.put(num, count - 1);
            }
        }
        
        // 转换为数组返回
        int[] res = new int[result.size()];
        for (int i = 0; i < result.size(); i++) {
            res[i] = result.get(i);
        }
        return res;
    }
}

解法二：双指针法（已排序数组）

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        
        List<Integer> result = new ArrayList<>();
        int i = 0, j = 0;
        
        while (i < nums1.length && j < nums2.length) {
            if (nums1[i] == nums2[j]) {
                result.add(nums1[i]);
                i++;
                j++;
            } else if (nums1[i] < nums2[j]) {
                i++;
            } else {
                j++;
            }
        }
        
        int[] res = new int[result.size()];
        for (int k = 0; k < result.size(); k++) {
            res[k] = result.get(k);
        }
        return res;
    }
}

进阶问题解答

• 已排序数组：使用双指针法，时间复杂度O(m+n)，空间复杂度O(1)
• nums1较小：对较小的数组构建哈希表更优
• 大数据量：使用外部排序或分批处理，避免一次性加载所有数据

2. 两个数组的交集

问题描述

给定两个数组，返回它们的交集，输出结果中的每个元素必须是唯一的。

示例说明：

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]

输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]

输出：[9,4]

解法：集合操作

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resultSet = new HashSet<>();
        
        // 将第一个数组的元素加入集合
        for (int num : nums1) {
            set1.add(num);
        }
        
        // 检查第二个数组中的元素是否在第一个集合中
        for (int num : nums2) {
            if (set1.contains(num)) {
                resultSet.add(num);
            }
        }
        
        // 转换为数组
        int[] result = new int[resultSet.size()];
        int index = 0;
        for (int num : resultSet) {
            result[index++] = num;
        }
        return result;
    }
}

与"交集II"的区别

特性	交集	交集II
元素唯一性	唯一	可重复
结果要求	集合	多重集
空间复杂度	O(min(m,n))	O(min(m,n))

3. 重塑矩阵

问题描述

将 m×n 矩阵重塑为 r×c 矩阵，保持原始数据的行遍历顺序。

示例说明：

示例 1：

输入：mat = [[1,2],[3,4]], r = 1, c = 4

输出：[[1,2,3,4]]

示例 2：

输入：mat = [[1,2],[3,4]], r = 2, c = 4

输出：[[1,2],[3,4]] // 无法重塑，返回原矩阵

解法：数学映射法

class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
        int m = mat.length, n = mat[0].length;
        
        // 检查重塑是否可行
        if (m * n != r * c) {
            return mat;
        }
        
        int[][] result = new int[r][c];
        
        // 使用数学映射：原矩阵的(i,j)对应新矩阵(i*n+j)/c, (i*n+j)%c
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                int totalIndex = i * n + j;
                int newRow = totalIndex / c;
                int newCol = totalIndex % c;
                result[newRow][newCol] = mat[i][j];
            }
        }
        
        return result;
    }
}

可视化理解

4. 区间加法 II

问题描述

给定 m×n 矩阵和操作数组，每次操作将左上角矩形区域加1，求最终矩阵中最大整数的个数。

示例说明：

示例 1：

输入：m = 3, n = 3, ops = [[2,2],[3,3]]

输出：4

解释：最大整数是2，有4个这样的元素

示例 2：

输入：m = 3, n = 3, ops = []

输出：9

解法：寻找最小重叠区域

class Solution {
    public int maxCount(int m, int n, int[][] ops) {
        int minA = m, minB = n;
        
        // 找到所有操作的最小重叠区域
        for (int[] op : ops) {
            minA = Math.min(minA, op[0]);
            minB = Math.min(minB, op[1]);
        }
        
        return minA * minB;
    }
}

算法原理

• 每次操作都是从(0,0)到(a,b)的矩形区域
• 被操作次数最多的区域是所有操作的交集
• 这个交集的大小就是minA × minB

5. 提莫攻击

问题描述

计算提莫攻击后艾希的总中毒时间，考虑中毒状态的重置机制。

示例说明：

示例 1：

输入：timeSeries = [1,4], duration = 2

输出：4

时间线：1(中毒) 2(中毒) 3(正常) 4(中毒) 5(中毒)

示例 2：

输入：timeSeries = [1,2], duration = 2

输出：3

时间线：1(中毒) 2(中毒) 3(中毒) - 第2秒攻击重置了计时器

解法：区间合并

class Solution {
    public int findPoisonedDuration(int[] timeSeries, int duration) {
        if (timeSeries.length == 0) return 0;
        
        int total = 0;
        
        for (int i = 0; i < timeSeries.length - 1; i++) {
            // 计算当前攻击与下一次攻击的时间间隔
            int gap = timeSeries[i + 1] - timeSeries[i];
            // 如果间隔大于持续时间，则完整计入duration
            // 否则只计入间隔时间（因为会被重置）
            total += Math.min(gap, duration);
        }
        
        // 加上最后一次攻击的完整持续时间
        total += duration;
        
        return total;
    }
}

时间线分析

总结与技巧提炼

1. 集合操作技巧

• 哈希表应用：统计频率、去重操作
• 双指针优化：已排序数组的高效处理
• 空间权衡：根据数据特点选择合适的数据结构

2. 矩阵处理模式

• 数学映射：利用索引计算公式进行维度转换
• 边界检查：操作前验证参数的合理性
• 原地操作：尽量减少额外空间使用

3. 区间统计策略

• 重叠区域：通过找最小值确定最大操作区域
• 时间区间：处理重叠区间时使用min函数
• 累计统计：避免重复计算，使用增量方式

4. 实战建议

1. 理解问题本质：每个问题都有核心的数学模型
2. 多种场景考虑：空输入、边界值、极端情况
3. 复杂度分析：时间与空间的权衡选择
4. 代码可读性：清晰的变量命名和逻辑结构

复杂度对比总结

问题	最优时间复杂度	空间复杂度	关键技巧
交集II	O(m+n)	O(min(m,n))	哈希表/双指针
交集	O(m+n)	O(min(m,n))	集合操作
重塑矩阵	O(m×n)	O(1)	数学映射
区间加法	O(k)	O(1)	最小重叠
提莫攻击	O(n)	O(1)	区间合并

通过这五个经典问题的深入分析，我们掌握了数组和矩阵处理的多种重要技巧。这些方法不仅适用于具体问题，更能推广到更广泛的算法场景中，为解决复杂问题奠定坚实基础。