Question

如果$ returnintersection为true，我编写了以下perl代码来返回任意两个输入列表的交集列表。否则，它将返回任何一个公共元素，如果没有，则返回0。

通过十字路口，我指的是外卡匹配 - 一个列表中的123 *将与另一个列表中的12345匹配。

以下是输入和相应输出的示例。

getintersection (
 ['123*', '999', 'V890', '871'],
 ['10001', '8789', '999', '1234', 'V89*'], 
 1 
)
will return
('999', 'V890', '1234')

我想知道我是否可以用更好的方式编写它？我确信算法不是最好的算法。任何有助于降低其复杂性的事情都将受到赞赏！它的性能至关重要，因为它是一种非常常见的例程。（Performance =＆gt; speed，假设任一列表可以包含1到3000个元素之间的任何位置）

代码 -

    sub getintersection {
        my ($l1, $l2, $returnintersection) = @_;
        if (!$l1 || !$l2) {
                return $returnintersection ? undef : 0;
        }
        my ($small, $large);
        if (scalar @$l1 > scalar @$l2 ) {
                ($small, $large) = ($l2, $l1);
        }
        else {
                ($small, $large) = ($l1, $l2);
        }

        my (%lhash, %l_starred, %s_starred, @intersection);
        foreach my $l (@$large) {
                $lhash{$l} = 1;
                if ($l =~ m/^(.+)\*$/) {
                        $l_starred{$1} = 1;
                }
        }
        foreach my $s (@$small) {
                if ($lhash{$s}) {
                        return $s if (!$returnintersection);
                        push @intersection, $s;
                }
                else {
                        foreach my $k (keys %l_starred) {
                                if ($s =~ /^$k/) {
                                        return $s if (!$returnintersection);
                                        push @intersection, $s;
                                }
                        }
                }
                if ($s =~ m/^(.+)\*$/) {
                        $s_starred{$s} = 1;
                }
        }
        foreach my $s (keys %s_starred) {
                foreach my $l (@$large) {
                        if ($l =~ /^$s/) {
                                return $l if (!$returnintersection);
                                push @intersection, $l;
                        }
                }
        }

        return $returnintersection ? @intersection : scalar @intersection;
}

Answer 1

在我阅读它时，您的实现无法区分小型和大型集合。即便如此，真正重要的是哪一组具有最多的星号元素，因为它们无法以线性复杂性处理。

首先，看看不匹配的可能组合：

Set 1       | Set 2
Normal      | None
Starred     | None
None        | Normal
None        | Starred

然后是匹配的可能组合：

Normal      | Normal
Starred     | Normal
Normal      | Starred
Starred     | Starred

很明显，任何可以使用哈希查找匹配的东西都应该首先完成，因为复杂性是线性的，所以算法的第一部分应该是：

for all elements in set1
    if element is normal, put in %normal_1_lookup
    otherwise put in @star_1
for all elements in set2
    if element is normal, put in %normal_2_lookup
    otherwise put in @star_2

for intersection of %normal_1_lookup, %normal_2_lookup
    put element in result
    delete element from %normal_1_lookup and %normal_2_lookup

你可以通过将计算交集的最后一个循环折叠到计算%normal_2_lookup的第二个循环来优化这个，但我这样写是为了使它更具可读性。

现在所有的光照都已经完成，已经匹配的元素已被删除，你不需要迭代任何东西来知道哪些元素是星星，哪些元素不是。

for all elements is @star_1
    for all elements in %normal_2_lookup
        if star_1 element matches normal_2 element
            put normal_2 element in result set
            delete normal_2 element from %normal_2_lookup

现在重复切换两组。

最后，您可以针对@star_1添加@star_2的匹配项，但我不确定是否有意。

这应该将复杂度降低到o（s_1 * n_2 + s_2 * n_1）（如果你想匹配两组中的星级元素，则添加s_1 * s_2）而不是看似o（n_1 * n_2）。

如果您想进一步优化，可以对其中一个集合中的所有元素使用Tries进行匹配。

Answer 2

Dunno这是多么超快，请用你的测试数据来计算它！

它的工作原理是将每个输入列表转换为像这样的正则表达式

^99$|^23$|^34$|^6$|^1$|^451$

然后grep将正则表达式应用于其他列表。另一个grep删除重复项，然后重复列表的键作为答案返回

use Data::Dumper;
sub fixedra {
    my $l=shift;
    my $retval = join("|",map { qq#^$_\$#; } @$l);
    $retval =~ s/\*/.*/g;  #convert regexp to work as requirements
    return $retval;
    }



sub getintersection {
    my $a=shift;
    my $b=shift;
    my $ra=fixedra($a);
    my $rb=fixedra($b);
    my %rethash=();
    grep($rethash{$_}++, grep(/$ra/, @$b), grep(/$rb/, @$a));
    return [keys %rethash];
}

print Dumper(getintersection (
 ['123*', '999', 'V890', '871'],
 ['10001', '8789', '999', '1234', 'V89*'], 
));

提高查找两个列表的自定义交集的perl代码的性能

2 个答案: