12-二分-索引二分-寻找右区间

这是二分法的第十二篇算法，力扣链接

给你一个区间数组 intervals ，其中 intervals[i] = [starti, endi] ，且每个 starti 都 不同 。

区间 i 的 右侧区间 可以记作区间 j ，并满足 startj >= endi ，且 startj 最小化 。注意 i 可能等于 j 。

返回一个由每个区间 i 的 右侧区间 在 intervals 中对应下标组成的数组。如果某个区间 i 不存在对应的 右侧区间 ，则下标 i 处的值设为 -1 。

 

示例 1：

输入：intervals = [[1,2]]
输出：[-1]
解释：集合中只有一个区间，所以输出-1。

示例 2：

输入：intervals = [[3,4],[2,3],[1,2]]
输出：[-1,0,1]
解释：对于 [3,4] ，没有满足条件的“右侧”区间。
对于 [2,3] ，区间[3,4]具有最小的“右”起点;
对于 [1,2] ，区间[2,3]具有最小的“右”起点。

示例 3：

输入：intervals = [[1,4],[2,3],[3,4]]
输出：[-1,2,-1]
解释：对于区间 [1,4] 和 [3,4] ，没有满足条件的“右侧”区间。
对于 [2,3] ，区间 [3,4] 有最小的“右”起点。

我尝试用人类语言翻译一下这道题，这个数组的每一个值都属于一个左闭右闭的区间，将数组的所有区间连到一起，然后判断每一个数组的区间的右侧是哪个区间，如果没有就返回-1。此外，返回的区间可以是自己。

或者换个思路，可以直接查找数组里每个大于等于intervals[i][1]左边界的最小值，有就返回，没有就返回-1。

老规矩，先上暴力法，逐一查找，记录最小值。

func findRightInterval(intervals [][]int) []int {
	result := make([]int, len(intervals))
	for i, cInterval := range intervals {
		minIndex := -1
		for j, interval := range intervals {
			if interval[0] >= cInterval[1] {
				if minIndex == -1 {
					minIndex = j
				} else if interval[0] <= intervals[minIndex][0] {
					minIndex = j
				}
			}
		}
		result[i] = minIndex
	}
	return result
}

二分法查找：

这个思路需要有序数组，然后二分法查找。我们可以按照左边界排序先，然后逐一查找，挺有意思的，这里借用了数组长度进行记录index。

func findRightInterval(intervals [][]int) []int {
	// Mark now index.
	for i, _ := range intervals {
		intervals[i] = append(intervals[i], i)
	}
	sort.Slice(intervals, func(i, j int) bool { return intervals[i][0] < intervals[j][0] })
	result := make([]int, len(intervals))
	for _, interval := range intervals {
		l, r := 0, len(intervals)-1
		for l <= r {
			mid := l + (r-l)/2
			if intervals[mid][0] >= interval[1] {
				r = mid - 1
			} else {
				l = mid + 1
			}
		}
		if l < len(intervals) {
			result[interval[2]] = intervals[l][2]
		} else {
			result[interval[2]] = -1
		}
	}
	return result
}

还有一个解法，是标准的空间换时间，我们开辟两个数组，一个是存intervals[i][0]从小到大的，一个是存intervals[i][1]从大到小的数组。然后我们就可以用双指针解决这个问题。不管如何，我们还是要照常记录索引地址。

func findRightInterval(intervals [][]int) []int {
	rightBoundIntervals, leftBoundIntervals := make([][]int, len(intervals)), make([][]int, len(intervals))
	for i, _ := range intervals {
		leftBoundIntervals[i] = append(intervals[i], i)
		rightBoundIntervals[i] = append(intervals[i], i)
	}
	sort.Slice(leftBoundIntervals, func(i, j int) bool { return leftBoundIntervals[i][0] < leftBoundIntervals[j][0] })
	sort.Slice(rightBoundIntervals, func(i, j int) bool { return rightBoundIntervals[i][1] < rightBoundIntervals[j][1] })
	result := make([]int, len(leftBoundIntervals))
	leftIndex := 0
	for _, rightInterval := range rightBoundIntervals {
		for leftIndex < len(leftBoundIntervals) && leftBoundIntervals[leftIndex][0] < rightInterval[1] {
			leftIndex++
		}
		if leftIndex < len(leftBoundIntervals) {
			result[rightInterval[2]] = leftBoundIntervals[leftIndex][2]
		} else {
			result[rightInterval[2]] = -1
		}
	}
	return result
}

当然，还是二分法更节约资源和省时间。