寻找多个区间之间的最长间隔

Question

假设您有一个变量 $n 表示时间线上的多个分区，以及一个可变长度的间隔数组：

$n = 10;
$intervals = [
  [1, 2],
  [2, 2],
  [5, 6],
  [8, 10],
];

问题是在时间轴上找到这些间隔之间的最大差距。对于上述问题，我们有两个长度为 2 和 1 的间隙，所以答案应该是 2。为了更好地可视化它：

我的直截了当的方法效率不高...

1. 初始化一个长度为 $n 的空时间线数组，其中每个元素设置为“E”，如空。
2. Foreach 在每个间隔上循环，并从间隔开始到间隔结束创建另一个 for 循环，并将时间线数组中的这些元素设置为“T”。
3. 遍历时间线数组并启动一个 $counter

我可以做哪些改进？

请注意：

• 间隔始终根据其起始位置进行排序。
• 间隔不必从时间线的开头开始，也不必在时间线的末尾结束。因此，在第一个间隔之前可能会有一个间隙，在最后一个间隔之后可能会有一个间隙。
• 间隔可以重叠。所以简单地计算下一个间隔的开始减去这个间隔的结束是行不通的......考虑这个例子：[1,5] [2,4] [6,10] [6,8]

Answer 1

<?php

$n = 10;
$intervals = [
  [1, 2],
  [2, 2],
  [5, 6],
  [8, 10]
];

$non_overlapping = [];
$start = -1;
$end = -1;

foreach($intervals as $index => $interval){
    if($start == -1) $start = $interval[0];
    if($end == -1) $end = $interval[1];

    if($index == 0) continue; // since it's first index

    if($interval[0] >= $end){
        $non_overlapping[] = [$start,$end];
        $start = $interval[0];
        $end = $interval[1];
    }else{
        $end = max($end,$interval[1]);
    }
}

$non_overlapping[] = [$start,$end];
$maximum_gap = 0;
$prev_end = 0;

foreach($non_overlapping as $index => $interval){
    $maximum_gap = max($maximum_gap,$interval[0] - $prev_end - 1);
    $prev_end = $interval[1];
}

$maximum_gap = max($maximum_gap,$n - $prev_end);

echo $maximum_gap;

• 由于您的区间是根据开始时间排序的，因此我们制作了一个新的非重叠区间数组。
• 现在，我们只需将新的开始时间与之前的结束时间相减，最后将最后的结束时间与$n 本身相减，然后找到最大差距。

Answer 2

更新的解决方案：-

$intervals = [
    [1,2],
    [2,2],
    [5,6],
    [8,10]
];
$rr = [];
foreach($intervals as $v){
    $rr[] = range($v[0],$v[1]);
}
$n = 10;
$range      = range(1,$n);
$diff =     array_diff($range,array_values(array_unique(array_merge(...$rr))));
$r = groupConsecutive($diff);

$max = 0;
if (count($r)) {
    foreach ($r as $gap) {
        $length = 1;
        if (is_array($gap)) $length = count($gap);
        if ($max < $length) $max = $length;
    }
}

echo $max;

function  groupConsecutive($array) {
   $ret  = array();
   $temp = array();
   foreach($array as $val) {
      if(next($array) == ($val + 1))
         $temp[] = $val;
      else
         if(count($temp) > 0) {
            $temp[] = $val;
            $ret[]  = $temp;
            $temp   = array();
         }
         else
            $ret[] = $val;
   }
   return $ret;
}

DEMO

Answer 3

如果分区已排序（如您的示例中所示）。您可以遍历分区并创建一个新数组，其中包含：

• 第一个数组中区间的原始位置
• 分区的第一个元素与前一个分区的最后一个元素的距离。

这样，您将获得分区之间的间隙列表。然后，您只需对这些空白进行排序并取最后一个。

但正如我所说，这是假设您的分区已排序。

有一个例子，然后你按值的第二个元素对$gaps 进行排序并取最后一个。

<?php                                                                                                                                                                                                                                                         

$n = 10;
$intervals = [
  [1, 2],
  [2, 2],
  [5, 6],
  [8, 10],
];

$gaps = array();

$prev_range_max = 1;
for ($i = 0; $i < count($intervals); $i++) {
    $gaps[] = Array($i, $intervals[$i][0] - $prev_range_max);
    $prev_range_max = $intervals[$i][1];
}

Answer 4

我们可以有一个简单的 O(n) 时间 O(1) 空间算法来跟踪我们在迭代按开始位置排序的间隔时所处的间隔。当前间隔开始于：

left = interval[0][0]
right = interval[0][1]
i = 1 // pointer
n = list length
max_gap = 0

那么，

while i < n and interval[i][0] <= right:
  // update right
  right = max(right, interval[i][1])
  i = i + 1

现在，如果没有间隙，我们要么位于列表的末尾，要么处于至少从 (right + 1) 开始的新间隔（我认为在您的情况下不符合差距）。

所以这里更新当前最大的gap，重复while程序。

max_gap = max(
  max_gap,
  interval[i][0] - right - 1
)
left = interval[i][0]
right = interval[i][1]

JavaScript 示例：

function f(A){
  console.log(JSON.stringify(A))
  let left = A[0][0]
  let right = A[0][1]
  console.log(`i: 0, (${ left }, ${ right })`)
  let i = 1 // pointer
  let n = A.length
  let max_gap = 0

  while (i < n){
    while (i < n && A[i][0] <= right){
      // update right
      right = Math.max(right, A[i][1])
      console.log(`i: ${ i }, (${ left }, ${ right })`)
      i = i + 1
    }

    if (i < n){
      max_gap = Math.max(
        max_gap,
        A[i][0] - right - 1
      )
      console.log(`i: ${ i }, max_gap: ${ max_gap }`)
      left = A[i][0]
      right = A[i][1]
    }
  }

  return max_gap
}

let examples = [
  [[1,5], [2,4], [6,10], [6,8]],
  [[1, 2], [2, 2], [5, 6], [8, 10]],
  [[2,4], [5,8], [9,10]],
  [[1,1], [5,6], [9,10]]
]

for (let ex of examples)
  console.log(`result: ${ f(ex) }\n\n`)

Answer 5

我正在描述一种非常有效的方法-

1. 如果间隔未根据开始时间排序- 首先根据开始时间对区间数组进行排序。 最坏情况复杂度 O(nlogn)。如果它已排序，那么我们不必做任何事情。

2. 从第二个元素开始遍历排序的区间数组，如果开始时间大于最后一个区间的结束时间，则每次迭代 - 计算差值。

3. 比较每次迭代中的差异，找出最大差异。

   复杂性- 未排序数组- O(nlogn)+ O(n) 排序数组 - O(n)。

伪代码--

例子--