Question

我有两套范围。每个范围是一对整数（开始和结束），表示单个较大范围的某个子范围。两组范围的结构与此类似（当然...... s将替换为实际数字）。

$a_ranges =
{
  a_1 =>
  {
    start => ...,
    end   => ...,
  },
  a_2 =>
  {
    start => ...,
    end   => ...,
  },
  a_3 =>
  {
    start => ...,
    end   => ...,
  },
  # and so on
};

$b_ranges =
{
  b_1 =>
  {
    start => ...,
    end   => ...,
  },
  b_2 =>
  {
    start => ...,
    end   => ...,
  },
  b_3 =>
  {
    start => ...,
    end   => ...,
  },
  # and so on
};

我需要确定集合A的哪些范围与集合B的范围重叠。给定两个范围，很容易确定它们是否重叠。我只是使用双循环来执行此操作 - 循环遍历外部循环中集合A中的所有元素，循环遍历内部循环中集合B的所有元素，并跟踪哪些元素重叠。

我对这种方法有两个问题。首先，重叠空间非常稀疏 - 即使每组中有数千个范围，我希望集A中的每个范围与集合B中的1或2个范围重叠。我的方法列举了每一种可能性，即矫枉过正。这导致了我的第二个问题 - 它的扩展非常差。当每组中有数百个范围时，代码会很快完成（亚分钟），但如果每组中有数千个范围，则需要很长时间（+/- 30分钟）。

有没有更好的方法可以索引这些范围，以便我不会对重叠进行这么多不必要的检查？

更新：我正在寻找的输出是两个哈希值（每组范围一个），其中键是范围ID，值是另一组中范围的ID与此集合中的给定范围重叠。

Answer 1

这听起来像interval tree的完美用例，{{3}}是专为支持此操作而设计的数据结构。如果你有两组大小为m和n的区间，那么你可以在时间O（m lg m）中将其中一组构建到一个区间树中，然后在时间O（n lg m + k）中进行n次交叉查询，其中k是您找到的交叉点总数。这给出了O（（m + n）lg m + k）的净运行时间。请记住，在最坏的情况下k = O（nm），所以这并不比你拥有的更好，但是对于交叉点数量稀疏的情况，这可能比你拥有的O（mn）运行时间要好得多现在

我没有太多使用区间树的经验（在Perl中没有经验，对不起！），但从描述看起来它们似乎不应该那么难建立。如果一个人不存在，我会非常惊讶。

希望这有帮助！

Answer 2

如果您不是完全依赖于perl; R中的IRanges包处理区间运算。它具有非常强大的原语，用它们编写解决方案可能很容易。

第二点是，如果间隔有额外的结构，问题可能会变得非常容易;例如，如果在每组范围内没有重叠（在这种情况下，可以同时筛选两个有序组的线性方法）。即使没有这样的结构，你可以做的最少的事情是按起点对一组范围进行排序，而另一组按结束点进行排序，然后一旦匹配不再可能就突破内循环。当然，现有的和通用的算法和数据结构（如前面提到的区间树）是最强大的。

Answer 3

有几个现有的CPAN模块可以解决这个问题，我已经开发了2个：Data :: Range :: Compare和Data :: Range :: Compare :: Stream

Data :: Range :: Compare仅适用于内存中的数组，但支持通用范围类型。

Data :: Range :: Compare :: Stream通过迭代器与数据流一起工作，但它需要理解OO Perl以扩展到通用数据类型。如果要处理非常大的数据集，建议使用Data :: Range :: Compare :: Stream。

以下是Data :: Range :: Compare :: Stream。

的Examples文件夹的摘录形式

鉴于这3组数据：

Numeric Range set: A contained in file: source_a.src
+----------+
| 1 - 11   |
| 13 - 44  |
| 17 - 23  |
| 55 - 66  |
+----------+

Numeric Range set: B contained in file: source_b.src
+----------+
| 0  - 1   |
| 2  - 29  |
| 88 - 133 |
+----------+

Numeric Range set: C contained in file: source_c.src
+-----------+
| 17  - 29  |
| 220 - 240 |
| 241 - 250 |
+-----------+

预期输出为：

+--------------------------------------------------------------------+
| Common Range | Numeric Range A | Numeric Range B | Numeric Range C |
+--------------------------------------------------------------------+
| 0 - 0        |   No Data       |   0 - 1         |   No Data       |
| 1 - 1        |   1 - 11        |   0 - 1         |   No Data       |
| 2 - 11       |   1 - 11        |   2 - 29        |   No Data       |
| 12 - 12      |   No Data       |   2 - 29        |   No Data       |
| 13 - 16      |   13 - 44       |   2 - 29        |   No Data       |
| 17 - 29      |   13 - 44       |   2 - 29        |   17 - 29       |
| 30 - 44      |   13 - 44       |   No Data       |   No Data       |
| 55 - 66      |   55 - 66       |   No Data       |   No Data       |
| 88 - 133     |   No Data       |   88 - 133      |   No Data       |
| 220 - 240    |   No Data       |   No Data       |   220 - 240     |
| 241 - 250    |   No Data       |   No Data       |   241 - 250     |
+--------------------------------------------------------------------+

源代码可以在这里找到。

#!/usr/bin/perl

use strict;
use warnings;
use Data::Dumper;
use lib qw(./ ../lib);

# custom package from FILE_EXAMPLE.pl
use Data::Range::Compare::Stream::Iterator::File;


use Data::Range::Compare::Stream;
use Data::Range::Compare::Stream::Iterator::Consolidate;
use Data::Range::Compare::Stream::Iterator::Compare::Asc;

my $source_a=Data::Range::Compare::Stream::Iterator::File->new(filename=>'source_a.src');
my $source_b=Data::Range::Compare::Stream::Iterator::File->new(filename=>'source_b.src');
my $source_c=Data::Range::Compare::Stream::Iterator::File->new(filename=>'source_c.src');

my $consolidator_a=new Data::Range::Compare::Stream::Iterator::Consolidate($source_a);
my $consolidator_b=new Data::Range::Compare::Stream::Iterator::Consolidate($source_b);
my $consolidator_c=new Data::Range::Compare::Stream::Iterator::Consolidate($source_c);


my $compare=new  Data::Range::Compare::Stream::Iterator::Compare::Asc();

my $src_id_a=$compare->add_consolidator($consolidator_a);
my $src_id_b=$compare->add_consolidator($consolidator_b);
my $src_id_c=$compare->add_consolidator($consolidator_c);



print "  +--------------------------------------------------------------------+
  | Common Range | Numeric Range A | Numeric Range B | Numeric Range C |
  +--------------------------------------------------------------------+\n";

my $format='  | %-12s |   %-13s |   %-13s |   %-13s |'."\n";
while($compare->has_next) {
  my $result=$compare->get_next;
  my $string=$result->to_string;
  my @data=($result->get_common);
  next if $result->is_empty;
  for(0 .. 2) {
     my $column=$result->get_column_by_id($_);
     unless(defined($column)) {
      $column="No Data";
    } else {
      $column=$column->get_common->to_string;
    }
     push @data,$column;


   }
  printf $format,@data;

  } 
 print "  +--------------------------------------------------------------------+\n";

Answer 4

尝试Tree :: RB但要找到互斥的范围，没有重叠

如果我有大约10000个段并且必须为每个离散数找到段，那么性能也不错。我的输入有3亿条记录。我恳求将它们分成不同的桶。就像分区数据一样。 Tree :: RB很棒。

$var = [
[0,90],
[91,2930],
[2950,8293]
.
.
.
]

我的查询值是10,99,991 ......

基本上我需要给定数字范围的位置

使用以下比较函数，我使用类似的东西：

my $cmp = sub
{
    my ($a1, $b1) = @_;

    if(ref($b1) && ref($a1))
    {
        return ($$a1[1]) <=> ($$b1[0]);
    }

    my $ret = 0;

    if(ref($a1) eq 'ARRAY')
    {
        #
        if($$a1[0] <= $b1 && $b1 >= $$a1[1])
        {
            $ret =  0;
        }
        if($$a1[0] < $b1)
        {
            $ret =  -1;
        }
        if($$a1[1] > $b1)
        {
            $ret =  1;
        }
    }
    else
    {
        if($$b1[0] <= $a1 && $a1 >= $$b1[1])
        {
            $ret =  0;
        }
        if($$b1[0] > $a1)
        {
            $ret =  -1;
        }
        if($$b1[1] < $a1)
        {
            $ret =  1;
        }
    }

    return $ret;
}

Answer 5

我应该检查时间，以了解它是否是最快的方式，但根据数据的结构，你应该试试这个：

use strict;

my $fromA = 12;
my $toA = 15;
my $fromB = 7;
my $toB = 35;

my @common_range = get_common_range($fromA, $toA, $fromB, $toB);
my $common_range = $common_range[0]."-".$common_range[-1];

sub get_common_range {
  my @A = $_[0]..$_[1];
  my %B = map {$_ => 1} $_[2]..$_[3];
  my @common = ();

  foreach my $i (@A) {
    if (defined $B{$i}) {
      push (@common, $i);
    } 
  }
  return sort {$a <=> $b} @common;
}

在Perl中确定范围重叠的最快方法

5 个答案: