无重叠区间

怎样从“intervals=[[1,2],[2,3],[3,4],[1,3]] 最少移除使无重叠。”推导出 区间 · 无重叠，并证明每次状态变化都不会漏掉答案？

中心结论：按 end 排序贪心,能留则留(end 更小优先)。

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

1. 可以认为区间的终点总是大于它的起点。 2. 区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

在本站主例中，intervals=[[1,2],[2,3],[3,4],[1,3]] 最少移除使无重叠。

算法最终需要得到或观察：最少移除 1。

两两比较所有区间会重复检查重叠关系；排序后只需维护当前已合并边界或上一个结束点。

暴力方案的价值是确认题意并提供正确性基线。它通常会覆盖所有候选， 但没有保存已经确认的信息，因此同一状态会被重新计算。

1. 1建模把输入翻译成“区间时间轴”，明确答案需要观察什么。
2. 2状态只维护 排序、prev end、移除计数。
3. 3转移每一步按照 按 end 排序贪心,能留则留(end 更小优先)。
4. 4收尾读取 最少移除 1。，并复核边界与复杂度。

排序把二维的任意关系压缩成从左到右的一次扫描。

这道题不是为了记住一个组件名称，而是为了让状态具有可解释的语义：排序、prev end、移除计数。

给定一组区间，问最少删除多少个区间，可以让这些区间之间互相不重叠。注意，给定区间的起始点永远小于终止点。[1,2] 和 [2,3] 不叫重叠。 这一题可以反过来考虑，给定一组区间，问最多保留多少区间，可以让这些区间之间相互不重叠。先排序，判断区间是否重叠。 这一题一种做法是利用动态规划，模仿最长上升子序列的思想，来解题。 这道题另外一种做法是按照区间的结尾进行排序，每次选择结尾最早的，且和前一个区间不重叠的区间。选取结尾最早的，就可以给后面留出更大的空间，供后面的区间选择。这样可以保留更多的区间。这种做法是贪心算法的思想。

按 end 排序贪心,能留则留(end 更小优先)。

执行过程中持续维护：排序、prev end、移除计数。

正确性依赖以下不变量：按结束早的留更多空间。

面试时可以压缩为：sort by end 贪心 O(n log n)。

落到当前题，执行机制可以压缩为：按 end 排序贪心,能留则留(end 更小优先)。每一次更新都必须保持核心不变量，而不是只让样例碰巧得到正确答案。

1. 1题目与输入intervals=[[1,2],[2,3],[3,4],[1,3]] 最少移除使无重叠。 因为：按 end 排序贪心,能留则留(end 更小优先)。
2. 2按结束时间排序结束越早,给后面留的空间越大。 因为：活动选择问题的经典贪心策略。
3. 3保留 [1,2],更新 lastEnd保留当前区间。 因为：不与已保留段重叠,安全加入。
4. 4保留 [2,3],更新 lastEnd保留当前区间。 因为：不与已保留段重叠,安全加入。
5. 5[1,3] 与上一段冲突,丢弃跳过冲突区间。 因为：保留它会减少后续可选空间。
6. 6保留 [3,4],更新 lastEnd保留当前区间。 因为：不与已保留段重叠,安全加入。
7. 7最少移除 1 段贪心结束,移除数 = 总数 - 保留数。 因为：按 end 排序贪心是最优的。
8. 8收尾与复杂度最少移除 1。 因为：时间 O(n) · 空间 O(1)。按 end 排序贪心,能留则留(end 更小优先)。

代码窗口不会按容易漂移的固定数字行号硬绑动画，而是根据当前语义阶段， 在完整 Go 实现中定位选择、计算、写回或返回分支。当前变量与高亮行一起变化。

import (
	"sort"
)

// 解法一 DP O(n^2) 思路是仿造最长上升子序列的思路
func eraseOverlapIntervals(intervals [][]int) int {
	if len(intervals) == 0 {
		return 0
	}
	sort.Sort(Intervals(intervals))
	dp, res := make([]int, len(intervals)), 0
	for i := range dp {
		dp[i] = 1
	}
	for i := 1; i < len(intervals); i++ {
		for j := 0; j < i; j++ {
			if intervals[i][0] >= intervals[j][1] {
				dp[i] = max(dp[i], 1+dp[j])
			}
		}
	}
	for _, v := range dp {
		res = max(res, v)
	}
	return len(intervals) - res
}

func max(a int, b int) int {
	if a > b {
		return a
	}
	return b
}

// Intervals define
type Intervals [][]int

func (a Intervals) Len() int {
	return len(a)
}
func (a Intervals) Swap(i, j int) {
	a[i], a[j] = a[j], a[i]
}
func (a Intervals) Less(i, j int) bool {
	for k := 0; k < len(a[i]); k++ {
		if a[i][k] < a[j][k] {
			return true
		} else if a[i][k] == a[j][k] {
			continue
		} else {
			return false
		}
	}
	return true
}

// 解法二 贪心 O(n)
func eraseOverlapIntervals1(intervals [][]int) int {
	if len(intervals) == 0 {
		return 0
	}
	sort.Sort(Intervals(intervals))
	pre, res := 0, 1

	for i := 1; i < len(intervals); i++ {
		if intervals[i][0] >= intervals[pre][1] {
			res++
			pre = i
		} else if intervals[i][1] < intervals[pre][1] {
			pre = i
		}
	}
	return len(intervals) - res
}

func main() {
    // 1. 主例
    //    输入：mode="non-overlapping", intervals=[[1,2],[2,3],[3,4],[1,3]]
    //    期望：最少移除 1。
    //
    // 2. 失败 / 未命中
    //    检查：按 start 排序不是最优贪心。
    //
    // 3. 边界
    //    空输入、单元素、最小合法规模，以及答案恰好落在边界的情况。
    //
    // 4. 迁移
    //    LC452 气球；LC56 合并
}

Go 参考实现基于 halfrost/LeetCode-Go 的 MIT 许可代码整理，并按本站教学结构补充解释与动画映射。

1. 1题意intervals=[[1,2],[2,3],[3,4],[1,3]] 最少移除使无重叠。
2. 2重复两两比较所有区间会重复检查重叠关系；排序后只需维护当前已合并边界或上一个结束点。
3. 3优化按 end 排序贪心,能留则留(end 更小优先)。
4. 4证明按结束早的留更多空间。
5. 5复杂度时间 O(n)，空间 O(1)