Как пересечь два массива диапазонов?

пусть a ряд быть массив из двух целых чисел:start и end (например,[40, 42]).

имея два массива диапазонов (которые отсортированы), я хочу найти оптимальный способ вычисления их пересечения (что приведет к другому массиву диапазонов):

A = [[1, 3], [7, 9], [12, 18]]
B = [[2, 3], [4,5], [6,8], [13, 14], [16, 17]]

перекресток:

[[2, 3], [7, 8], [13, 14], [16, 17]]

каков оптимальный алгоритм для этого?


наивным способом было бы проверить каждый из них со всеми другими, но это явно не оптимально.

я нашел аналогичный вопрос, задающий то же самое в VBA:пересечение двух массивов диапазонов

3 ответов


поскольку входные массивы отсортированы,это должно быть довольно просто. Я предполагаю, что диапазоны в любом входном массиве не пересекаются друг с другом (в противном случае "сортировка" будет неоднозначной). Рассмотрим один диапазон из каждого массива (определяемый индексами "текущий диапазон"a и b). Есть несколько случаев (каждый случай, кроме "полного перекрытия", имеет зеркальное изображение, где A и B сторнируются):

нет пересечение:

A[a]: |------|
B[b]:          |---|

потому что массивы отсортированы, A[a] не пересекаются ничего B, поэтому его можно пропустить (increment a).

частичное перекрытие (B[b] выходит за пределы A[a]):

A[a]: |-------|
B[b]:      |-------|

в этом случае добавьте пересечение к выходу, а затем увеличьте a, потому что A[a] не может пересекать что-либо еще в B.

сдерживание (возможно, с совпадением заканчивается):

A[a]: |------|
B[b]:   |--|

снова добавьте пересечение к выходу и на этот раз увеличьте b. Обратите внимание, что дальнейшая небольшая оптимизация заключается в том, что if A[a] и B[b] конец при том же значении, то вы можете увеличить b С B[b] также не может пересекать что-либо еще в A. (Случай совпадающих концов мог быть объединен в случай частичного перекрытия. Этот случай можно было бы назвать "строгого сдерживания".)

полный перекрытие:

A[a]: |------|
B[b]: |------|

добавьте пересечение к выходу и увеличьте оба a и b (ни один диапазон не может пересекать что-либо еще в другом массиве).

продолжить повторение выше, пока либо a или b запускает конец соответствующего массива, и все готово.

он должен быть!--50-->тривиальные просто перевести в код.

EDIT: чтобы создать резервную копию последнего предложения (хорошо, это не было trivial), вот моя версия вышеуказанного в коде. Это немного утомительно из-за всех случаев, но каждая ветвь довольно проста.

const A = [[1, 3], [7, 9], [12, 18]];
const B = [[2, 3], [4, 5], [6, 8], [13, 14], [16, 17]];

const merged = [];

var i_a = 0,
    i_b = 0;

while (i_a < A.length && i_b < B.length) {
  const a = A[i_a];
  const b = B[i_b];

  if (a[0] < b[0]) {
    // a leads b
    if (a[1] >= b[1]) {
      // b contained in a
      merged.push([b[0], b[1]]);
      i_b++;
      if (a[1] === b[1]) {
        // a and b end together
        i_a++;
      }
    } else if (a[1] >= b[0]) {
      // overlap
      merged.push([b[0], a[1]]);
      i_a++;
    } else {
      // no overlap
      i_a++;
    }
  } else if (a[0] === b[0]) {
    // a and b start together
    if (a[1] > b[1]) {
      // b contained in a
      merged.push([a[0], b[1]]);
      i_b++;
    } else if (a[1] === b[1]) {
      // full overlap
      merged.push([a[0], a[1]]);
      i_a++;
      i_b++;
    } else /* a[1] < b[1] */ {
      // a contained in b
      merged.push([a[0], a[1]]);
      i_a++;
    }
  } else /* a[0] > b[0] */ {
    // b leads a
    if (b[1] >= a[1]) {
      // containment: a in b
      merged.push([a[0], b[1]]);
      i_a++;
      if (b[1] === a[1]) {
        // a and b end together
        i_b++;
      }
    } else if (b[1] >= a[0]) {
      // overlap
      merged.push([a[0], b[1]]);
      i_b++
    } else {
      // no overlap
      i_b++;
    }
  }
}
console.log(JSON.stringify(merged));

вы просили оптимальный алгоритм. Я считаю, что мой очень близок к оптимальному. Он работает в линейном времени с количеством диапазонов в двух массивах, так как каждая итерация завершает обработку хотя бы одного диапазона (а иногда и двух). Она требует постоянн памяти плюс память необходима, что построила результат.

я должен отметить, что в отличие от ответа CertainPerformance (единственный другой ответ, опубликованный здесь в то время, когда я пишу это), мой код работает для любых данных числового диапазона, а не только для целых чисел. (Возможно, вы захотите заменить === С == в приведенном выше, если вы смешиваете числа и строковые представления чисел). Алгоритм CertainPerformance сглаживает диапазоны в массивы последовательных целых чисел, которые охватывают диапазоны. Если это количество целых чисел является n, то его алгоритм работает в O (n2) время и O (n) пространство. (Так, например, если бы один из диапазонов был [1, 50000], это потребовало бы памяти для 50 000 чисел и времени, пропорционального квадрату этого.)


идея, предложенная @Ted Hopp может быть реализован в меньшем количестве строк кода следующим образом:

var A = [[1, 3], [7, 9], [12, 18]];
var B = [[2, 3], [4, 5], [6, 8], [13, 14], [16, 17]];

var result = [];
var ai = 0, alength = A.length, ax, ay;
var bi = 0, blength = B.length, bx, by;
while (ai < alength && bi < blength) {
  ax = A[ai][0];
  ay = A[ai][1];
  bx = B[bi][0];
  by = B[bi][1];
  if (ay < bx) {
    // a ends before b
    ai++;
  } else if (by < ax) {
    // b ends before a
    bi++;
  } else {
    // a overlaps b
    result.push([ax > bx ? ax : bx, ay < by ? ay : by]);
    // the smaller range is considered processed
    if (ay < by) {
      ai++;
    } else {
      bi++;
    }
  }
}
console.log(result);

Ниже приведен комплексный тест с большими массивами:

var A = [];
var B = [];
var R = [];
(function(rangeArray1, rangeArray2, bruteForceResult) {
  // create random, non-overlapping, sorted ranges
  var i, n, x, y;
  for (i = 0, n = 0; i < 1000; i++) {
    x = n += Math.floor(Math.random() * 100) + 1;
    y = n += Math.floor(Math.random() * 100);
    rangeArray1.push([x, y]);
  }
  for (i = 0, n = 0; i < 1000; i++) {
    x = n += Math.floor(Math.random() * 100) + 1;
    y = n += Math.floor(Math.random() * 100);
    rangeArray2.push([x, y]);
  }
  // calculate intersections using brute force
  rangeArray1.forEach(function(a) {
    rangeArray2.forEach(function(b) {
      if (b[1] >= a[0] && a[1] >= b[0]) {
        bruteForceResult.push([Math.max(a[0], b[0]), Math.min(a[1], b[1])]);
      }
    });
  });
})(A, B, R);

var result = [];
var ai = 0, alength = A.length, ax, ay;
var bi = 0, blength = B.length, bx, by;
while (ai < alength && bi < blength) {
  ax = A[ai][0];
  ay = A[ai][1];
  bx = B[bi][0];
  by = B[bi][1];
  if (ay < bx) {
    // a ends before b
    ai++;
  } else if (by < ax) {
    // b ends before a
    bi++;
  } else {
    // a overlaps b
    result.push([ax > bx ? ax : bx, ay < by ? ay : by]);
    // the smaller range is considered processed
    if (ay < by) {
      ai++;
    } else {
      bi++;
    }
  }
}
console.log(JSON.stringify(R) === JSON.stringify(result) ? "test passed" : "test failed");

довольно просто, просто приличное количество кода для записи. Сплющить a и b в отдельные элементы вместо диапазонов найдите их пересечение и снова превратите его в массив диапазонов.

const a = [[1, 3], [7, 9], [12, 18]];
const b = [[2, 3], [4,5], [6,8], [13, 14], [16, 17]];
const rangeToArr = ([start, end]) => Array.from({ length: end - start + 1 }, (_, i) => start + i);
const flat = inputArr => inputArr.reduce((arr, elm) => arr.concat(...elm), []);
const aRange = flat(a.map(rangeToArr));
const bRange = flat(b.map(rangeToArr));
const intersection = aRange.filter(num => bRange.includes(num));
console.log(intersection);


// Have the intersection of elements
// now we have to turn the intersection back into an array of ranges again:
const { partialIntersectionRange, thisRangeStarted, lastNum }
= intersection.reduce(({ partialIntersectionRange, thisRangeStarted, lastNum }, num) => {
  // Initial iteration only: populate with initial values
  if (typeof thisRangeStarted !== 'number') {
    return { partialIntersectionRange, thisRangeStarted: num, lastNum: num };
  }
  // If this element is a continuation of the range from the last element
  // then just increment lastNum:
  if (lastNum + 1 === num) {
    return { partialIntersectionRange, thisRangeStarted, lastNum: num };
  }
  // This element is not a continuation of the previous range
  // so make a range out of [thisRangeStarted, lastNum] and push it to the range array
  // (in case thisRangeStarted === lastNum, only push a single value)
  if (thisRangeStarted !== lastNum) partialIntersectionRange.push([thisRangeStarted, lastNum]);
  else partialIntersectionRange.push([thisRangeStarted]);
  return { partialIntersectionRange, thisRangeStarted: num, lastNum: num };
}, { partialIntersectionRange: [] });
if (thisRangeStarted !== lastNum) partialIntersectionRange.push([thisRangeStarted, lastNum]);
else partialIntersectionRange.push([thisRangeStarted]);

console.log(JSON.stringify(partialIntersectionRange));

трудность заключается не в логике пересечения, а в том, чтобы отформатировать ее нужным образом.