1. 问题背景与核心需求
这道题目来自力扣（LeetCode）的算法题库，编号3507。题目要求我们通过移除特定元素对的方式，使得数组最终呈现有序状态。这类数组操作问题在实际开发中非常常见，比如数据库索引优化、内存整理等场景都会涉及类似操作。
核心需求可以拆解为：
- 操作规则：每次必须选择相邻元素中和最小的那一对
- 选择策略：当存在多个最小和的对时，选择最左边的一个
- 终止条件：最终数组必须满足非递减顺序（即nums[i] <= nums[i+1]）
2. 算法思路解析
2.1 暴力解法分析
最直观的解法是模拟题目描述的操作过程：
- 扫描数组找出所有相邻元素对
- 计算每对的和并记录最小值
- 移除最左边的那个最小和对
- 重复上述步骤直到数组有序
这种方法的时间复杂度为O(n^2)，在数组长度较大时（比如10^5量级）会非常低效。我们需要寻找更优解。
2.2 贪心算法优化
通过观察可以发现，当数组中存在nums[i] > nums[i+1]时，必须移除这对元素中的至少一个。贪心策略告诉我们：
- 应该优先移除对整体有序性破坏最大的元素
- 最小和对往往包含数组中较小的元素，移除它们有助于减少后续比较的复杂度
优化后的算法流程：
- 从左到右扫描数组
- 当发现nums[i] > nums[i+1]时：
a. 比较nums[i]和nums[i+1]的大小
b. 移除较小的那个元素（贪心选择） - 重复直到数组完全有序
这种方法可以将时间复杂度优化到O(n)，只需要一次遍历即可。
3. Java实现详解
3.1 基础实现
java复制public int[] makeArrayIncreasing(int[] nums) {
int n = nums.length;
boolean changed;
do {
changed = false;
int minSum = Integer.MAX_VALUE;
int removeIndex = -1;
// 找出最小和的对
for (int i = 0; i < n - 1; i++) {
int sum = nums[i] + nums[i+1];
if (sum < minSum) {
minSum = sum;
removeIndex = i;
}
}
// 如果找到需要移除的对
if (removeIndex != -1) {
// 创建新数组（移除选中的对）
int[] newNums = new int[n - 2];
System.arraycopy(nums, 0, newNums, 0, removeIndex);
System.arraycopy(nums, removeIndex + 2, newNums, removeIndex, n - removeIndex - 2);
nums = newNums;
n -= 2;
changed = true;
}
} while (changed && !isSorted(nums));
return nums;
}
private boolean isSorted(int[] nums) {
for (int i = 0; i < nums.length - 1; i++) {
if (nums[i] > nums[i+1]) return false;
}
return true;
}
3.2 优化版本
java复制public int[] makeArrayIncreasingOptimized(int[] nums) {
List<Integer> list = new ArrayList<>();
for (int num : nums) list.add(num);
boolean changed;
do {
changed = false;
int minSum = Integer.MAX_VALUE;
int removeIndex = -1;
for (int i = 0; i < list.size() - 1; i++) {
int sum = list.get(i) + list.get(i+1);
if (sum < minSum) {
minSum = sum;
removeIndex = i;
}
}
if (removeIndex != -1 &&
(list.get(removeIndex) > list.get(removeIndex+1))) {
list.remove(removeIndex);
list.remove(removeIndex); // 注意索引已经变化
changed = true;
}
} while (changed && !isSorted(list));
return list.stream().mapToInt(i->i).toArray();
}
private boolean isSorted(List<Integer> list) {
for (int i = 0; i < list.size() - 1; i++) {
if (list.get(i) > list.get(i+1)) return false;
}
return true;
}
4. 复杂度分析与优化
4.1 时间复杂度
- 基础版本：最坏情况下O(n^2)
- 优化版本：使用ArrayList后，平均情况可以降到O(n log n)
4.2 空间复杂度
- 两种实现都需要O(n)的额外空间
- 可以使用原地操作进一步优化空间使用
4.3 进一步优化思路
- 双指针法：维护两个指针，一个指向当前元素，一个用于构建新数组
- 堆优化：使用优先队列快速找到最小和的对
- 动态规划：记录每个位置的最优解，适用于变种问题
5. 边界条件与测试用例
5.1 常见边界情况
- 空数组或单元素数组
- 已经有序的数组
- 完全逆序的数组
- 所有元素相同的数组
- 包含Integer.MAX_VALUE/MIN_VALUE的数组
5.2 测试用例示例
java复制@Test
public void testMakeArrayIncreasing() {
Solution solution = new Solution();
// 已有序数组
assertArrayEquals(new int[]{1,2,3}, solution.makeArrayIncreasing(new int[]{1,2,3}));
// 需要移除一对
assertArrayEquals(new int[]{1,3}, solution.makeArrayIncreasing(new int[]{1,2,3}));
// 多对需要移除
assertArrayEquals(new int[]{1}, solution.makeArrayIncreasing(new int[]{1,0,2,0}));
// 边界值测试
assertArrayEquals(new int[]{}, solution.makeArrayIncreasing(new int[]{}));
assertArrayEquals(new int[]{1}, solution.makeArrayIncreasing(new int[]{1}));
}
6. 实际应用场景
这类算法在实际开发中有多种应用：
- 数据库优化：合并小的数据块时选择代价最小的操作
- 内存整理：合并空闲内存块时的策略选择
- 资源调度：选择最优的任务对进行合并处理
- 数据压缩：选择最相似的相邻数据进行合并
7. 常见问题与解决
7.1 为什么选择最左边的对？
这是题目明确的要求。在实际应用中，选择最左边的对可以保证操作的确定性，避免结果不一致的问题。从实现角度看，这简化了算法的设计。
7.2 如何处理大量数据？
对于大规模数据：
- 使用流式处理，不一次性加载全部数据
- 采用分治策略，将数组分成小块处理
- 使用并行计算加速处理过程
7.3 如何验证算法正确性？
- 编写全面的单元测试
- 使用数学归纳法证明
- 对比暴力解法的结果
- 检查每次操作后数组长度的变化是否符合预期
8. 算法扩展与变种
8.1 变种问题1：移除k对最小和
要求恰好移除k对元素，使得剩余数组尽可能有序。这时需要动态规划来记录不同移除策略的效果。
8.2 变种问题2：带权移除
每对元素有各自的移除代价，目标是使数组有序且总代价最小。这可以建模为图的最短路径问题。
8.3 变种问题3：多维数组
扩展到二维或更高维数组时，需要考虑更复杂的邻域关系和移除策略，通常会使用贪心算法结合局部搜索。