Question

参考对象：{1,5,6,9,10,11}

其他对象：

A   { 2, 4, 5, 6, 8, 10, 11 }
B   { 5, 7, 9, 10 }
C   { 2, 5, 6, 7, 9, 12 }
D   { 1, 3, 4, 5, 6, 8, 9, 10 }
E   { 6, 8 }
F   { 1, 2, 3, 4, 7, 8, 9, 13, 15 }
... { ... }

难度：它应该比O（n * m）

快

结果应该是：

Array
(
    [D] => 5
    [A] => 4
    [C] => 3
    [B] => 3
    [F] => 2
    [E] => 1
)

缓慢的解决方案：

ref = array(1, 5, 6, 9, 10, 11);

foreach (A, B, C, D,.. AS row)
{
    foreach (row AS col)
    {   
        if ( exist(col, ref) )
        {
            result[row] += 1;
        }
    }
}

sort (result)

..这是一个解决方案，但它的速度很慢。

是否有其他方式如模式识别，希望在O（log n）？

可以用其他表示法保存每个对象，例如：

ref = "15691011"
A = "2456811"

但我不知道这是否有帮助。

Answer 1

如果您对对象中的所有数据进行了排序，则可以通过比较行中的单个值而不是逐行整行来更快地执行此例程。

foreach (A, B, C, D,.. AS row)
{
    for (i = 0, j = 0; i < row.length && j < ref.length)
    {
        if (row[i] < ref[j]) i++;
        elseif (row[i] > ref[j]) j++;
        else {
            result[row] += 1;
            i++; j++;
        }
    }
}

在这种情况下，每行只传递一次引用，但此算法需要对所有数据进行排序。

Answer 2

您可以从最大的序列开始（它具有最大的更改以具有许多引用）。当您找到 - 例如 - 4 refs时，您可以安全地跳过少于4个元素的所有序列。

另一个早期退出是在当前序列不能超过当前最大值时中止检查序列。例如：您当前的最大值是6个元素。您正在处理大小为7的列表，但前两个元素没有引用。该列表的最高可达性为5，低于6，中止序列。

两种情况下的问题都是你无法构造完整的结果数组。

Answer 3

假设：

There are m lists apart from the reference object.
The lists are sorted initially.
There are no repetition of elements in any array.

扫描所有阵列并找出所有列表中的最大元素。您只需要检查每个列表中的最后一个元素。称之为MAX。
对于每个m + 1列表，使用MAX元素创建相应的布尔数组，并将其值初始化为零。
扫描所有数组并生成数组1的相应索引。

例如，示例引用对象{1,5,6,9,10,11}的相应数组应如下所示： {1,0,0,0,1,1,0,0,1,1,1,0,0，......}
现在，对于每个成对组合，您只需检查相应的索引，如果两者都为1，则递增计数。

上述算法可以在线性时间复杂度方面完成，与数据中元素的总数有关。

Answer 4

您应该使用搜索引擎中使用的其他技术。对于每个数字，您都有一个按排序顺序包含此数字的对象列表。在你的情况下

1  -> {D, F}    
5  -> {A, B, C, D}
6  -> {A, C, D, E}
9  -> {B, C, D, F}
10 -> {A, B, D}
11 -> {A}

合并此列表可以计算您的对象与列表中的对象的相似程度

A -> 4
B -> 3
C -> 2
D -> 5
E -> 1
F -> 2

排序后，您将获得所需的结果。如果只需要前k个元素，则应使用优先级队列。

查找与参考对象具有最多对应关系的对象

4 个答案: