Python 优化查找可比较的阵列对

定义：数组

A（a1，a2，…，A）

比

B（b1，b2，…，bn）

小，如果它们大小相等，并且

A_i>=B_i

从

1

到

n的每个
i
。

例如：

[1,2,3] >= [1,2,0]
[1,2,0] not comparable with [1,0,2]
[1,0,2] >= [1,0,0]

我有一个由大量这样的阵列组成的列表（大约10000个，但可以更大）。数组的元素是正整数。我需要从此列表中删除所有大于至少一个其他阵列的阵列。换句话说：如果存在这样的

B

，即

A>=B

，则删除

A

这是我目前的

O（n^2）

方法，速度非常慢。我只是将每个数组与所有其他数组进行比较，如果它更大，则将其删除。有没有办法加快速度

import numpy as np
import time
import random

def filter_minimal(lst):
    n = len(lst)
    to_delete = set()
    for i in xrange(n-1):
        if i in to_delete:
            continue
        for j in xrange(i+1,n):
            if j in to_delete: continue
            if all(lst[i]>=lst[j]):
                to_delete.add(i)
                break
            elif all(lst[i]<=lst[j]):
                to_delete.add(j)
    return [lst[i] for i in xrange(len(lst)) if i not in to_delete]


def test(number_of_arrays,size):
    x = map(np.array,[[random.randrange(0,10) for _ in xrange(size)] for i in xrange(number_of_arrays)])
    return filter_minimal(x)

a = time.time()
result = test(400,10)
print time.time()-a
print len(result)

将numpy导入为np
导入时间
随机输入
def过滤器_最小值（lst）：
n=长度（lst）
to_delete=set（）
对于X范围内的i（n-1）：
如果我想删除：
持续
对于x范围内的j（i+1，n）：
如果j in to_delete:继续
如果全部（lst[i]>=lst[j]）：
删除。添加（i）
打破
elif all（lst[i]可能不是您想要的，但这应该可以让您开始

import numpy as np
import time
import random

def compare(x,y):
    #Reshape x to a higher dimensional array
    compare_array=x.reshape(-1,1,x.shape[-1])
    #You can now compare every x with every y element wise simultaneously
    mask=(y>=compare_array)
    #Create a mask that first ensures that all elements of y are greater then x and
    #then ensure that this is the case at least once.
    mask=np.any(np.all(mask,axis=-1),axis=-1)
    #Places this mask on x
    return x[mask]

def test(number_of_arrays,size,maxval):
    #Create arrays of size (number_of_arrays,size) with maximum value maxval.
    x = np.random.randint(maxval, size=(number_of_arrays,size))
    y=  np.random.randint(maxval, size=(number_of_arrays,size))
    return compare(x,y)

print test(50,10,20)

首先，我们需要仔细检查目标。我们是否删除了>任何其他数组的任何数组，甚至是删除的数组？例如，如果A>B和C>A和B=C，那么我们是否只需要删除A或同时删除A和C？如果我们只需要删除不兼容的数组，那么这是一个更难的问题。这是一个非常困难的问题问题，因为数组集的不同分区可能是兼容的，所以您存在查找最大有效分区的问题

假设容易的问题，一个更好的方法来定义这个问题是，你要保留所有数组中至少有一个元素<所有其他数组中的对应元素。（在硬问题中，它是其他数组中的对应元素。我们不会考虑这个）。
第一阶段
要解决此问题，您需要将数组按列排列，然后对每一行进行排序，同时维护数组的键以及每一数组行到位置（位置列表）的映射。例如，您可能会在第1阶段得到如下结果：

第1行：B C D A E

第2行：C A E B D

第3行：E D B C A

这意味着对于第一个元素（第1行），数组B的值为>=C，C>=D，等等

现在，对该矩阵的最后一列进行排序和迭代（示例中为{eda}）。对于每个项目，检查元素是否小于其行中的前一个元素。例如，在第1行中，您将检查E是否
在所示的示例中，您将保留E、D、A（只要他们通过了上述测试）

第二阶段

这就剩下了B和C。对每一行的位置列表进行排序。例如，这将告诉您，具有B最小位置的行是第2行。现在，在最小值行（这里是第2行）中，对B和它下面的每个数组进行直接比较。这里只有一个这样的数组，D。对B和D进行直接比较。这表明，第3行中的B
现在我们对C做同样的事情。在C的例子中，我们只需要做一个直接比较，A.C支配A，所以我们不保留C

请注意，除了测试最后一列中没有出现的项目外，我们还需要测试第1阶段中具有相等性的项目。例如，假设第1行中的D=A=E。在这种情况下，我们必须对最后一列中涉及数组的每个相等性进行直接比较。因此，在这种情况下，我们直接将E与A和E与D进行比较。这显示了t控制D，因此E不保持不变

最后的结果是我们保留A、B和D。C和E被丢弃

该算法的总体性能在第1阶段为n2*logn，在第2阶段为{n下限，n*logn-上限}。因此，最大运行时间为n2*logn+nlogn，最小运行时间为n2logn+n。请注意，算法的运行时间为n立方n3。因为您比较了每个矩阵（n*n）每个比较是n个元素比较=n*n*n

一般来说，这将比暴力法快得多。大部分时间将用于对原始矩阵进行排序，这或多或少是一项不可避免的任务。请注意，您可以通过使用优先级队列而不是排序来改进我的算法，但生成的算法将复杂得多。
因此您希望最小的排序数组？您如何处理无法比较的数组…我没有遵循…不。我需要删除所有与较小数组比较的数组。例如：列表（[1,2,3]，[1,2,1]，[1,0,2]）。我需要删除[1,2,3]，因为它比[1,2,1]大。但是，我无法使用[1,0,2]因为它无法与任何其他数组进行比较。所以最后，您只剩下无法相互比较的数组？是的！正是我所需要的。这是求解丢番图方程组的TSS算法的一部分。为什么
[1,2,0]
和
[1,0,2]不可比？只是第一个n-1个索引不相等吗？另一个<代码> o（n^ 2）< /> >方法考虑，但可能要快得多的是使用更高维度的数字数组而不是所有这些循环。好，矢量化的方法，但这仍然是O（n ^ 2）。。如果我没有找到更好的方法，我可能会用纯C重写该函数。最多你会有O（N log（N））扩展到这一点，我相信所需想法的唯一实现是scipy KDTree，但当然不会做你希望它做的事情。好吧，numpy或scipy t中没有任何东西