首页　>　文章列表　>　LeetCode 冥想：插入间隔

LeetCode 冥想：插入间隔

154 2025-01-20

LeetCode 冥想：插入间隔

插入间隔的描述非常解释性：

给定一个不重叠的区间数组，其中区间[i] = [start_i, end_i] 表示第 i 个区间的开始和结束，区间按 start_i 升序排序。您还会获得一个间隔 newinterval = [start, end]，表示另一个间隔的开始和结束。

将 newinterval 插入间隔，使得间隔仍然按 start_i 升序排序，并且间隔仍然没有任何重叠间隔（如有必要，合并重叠间隔）。

返回间隔插入后。

注意您不需要就地修改间隔。您可以创建一个新数组并返回它。

例如：

input: intervals = [[1, 3], [6, 9]], newinterval = [2, 5]
output: [[1, 5], [6, 9]]

或者：

input: intervals = [[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]], newinterval = [4, 8]
output: [[1, 2], [3, 10], [12, 16]]

explanation: because the new interval [4, 8] overlaps with [3, 5], [6, 7], [8, 10].

我们可以从创建一个结果数组开始，结果:

let result = [];

然后，遍历所有间隔，我们需要检查是否要将新间隔放在当前间隔之前或之后，或，它们是否重叠，因此需要合并。

正如我们在本章介绍中所看到的，两个间隔不会重叠，如果一个的开始严格大于另一个的结束，或者，如果一个的结束严格小于比对方的开始。

当这两种情况都为假时，它们会重叠。

首先，我们可以检查newinterval是否在interval之前。事实上，如果我们首先检查这一点（我们可以找到放置 newinterval 的“最早”位置），我们可以立即返回新构造的结果。
这也是贪婪方法。

for (let i = 0; i < intervals.length; i++) {
  const interval = intervals[i];

  // newinterval is before interval
  if (newinterval[1] < interval[0]) {
    result.push(newinterval);
    return [...result, ...intervals.slice(i)];
  }
  /* ... */  
}

但是，如果 newinterval 出现在我们正在查看的当前间隔之后，我们可以将当前间隔推入我们的结果：

for (let i = 0; i < intervals.length; i++) {
  /* ... */
  // newinterval is after interval
  else if (newinterval[0] > interval[1]) {
    result.push(interval);
  }
}

最后一个选项是当它们重叠时，在这种情况下，我们需要合并两个间隔。我们可以再次创建 newinterval，将间隔的最小值作为新间隔的 start，将它们的最大值作为 end：

for (let i = 0; i < intervals.length; i++) {
  /* ... */
  // overlapping, create newinterval
  else {
    newinterval = [
      math.min(newinterval[0], interval[0]),
      math.max(newinterval[1], interval[1])
    ];
  }
}

我们的循环目前如下所示：

for (let i = 0; i < intervals.length; i++) {
  const interval = intervals[i];

  // newinterval is before interval
  if (newinterval[1] < interval[0]) {
    result.push(newinterval);
    return [...result, ...intervals.slice(i)] 

  // newinterval is after interval
  } else if (newinterval[0] > interval[1]) {
    result.push(interval);

  // overlapping, create newinterval
  } else {
    newinterval = [math.min(newinterval[0], interval[0]), math.max(newinterval[1], interval[1])];
  }
}

我们还需要推送我们创建的最新的 newinterval。最后，我们可以返回结果：

function insert(intervals: number[][], newinterval: number[]): number[][] {
  /* ... */
  result.push(newinterval);
  return result;
}

最后，解决方案如下所示：

function insert(intervals: number[][], newInterval: number[]): number[][] {
  let result = [];
  for (let i = 0; i < intervals.length; i++) {
    const interval = intervals[i];

    // newInterval is before interval
    if (newInterval[1] < interval[0]) {
      result.push(newInterval);
      return [...result, ...intervals.slice(i)] 

    // newInterval is after interval
    } else if (newInterval[0] > interval[1]) {
      result.push(interval);

    // overlapping, create newInterval
    } else {
      newInterval = [Math.min(newInterval[0], interval[0]), Math.max(newInterval[1], interval[1])];
    }
  }

  result.push(newInterval);
  return result;
}