Algorithm 仅比较已更新列表的高效算法

即使描述这个问题也很难，但我会尝试一下。我已经为此挣扎了几天，决定在这里提问

好的，我试着对“概念”或我所说的“事物”进行建模。只是一般的概念。这与处理逻辑有关

因此，每个“事物”都是由它与其他事物的关系来定义的。我将其存储为每个关系5位的集合。“东西”可以是这样的：

class Thing {
    char* Name;
    HashTable<Thing*, int> Relationships;
}

class Thing {
    char* Name;
    HashTable<Thing*, int> Relationships;
    ArrayDefinition* ArrayDef;
}

static CurrRel = 0;
CurrRel++; // the actual number doesn't matter, it's just used for matching

foreach(Arr in this->UsedInTheseDefs) {
    Arr->RelationModifiedTag.Add( CurrRel );
}
foreach(Arr in other->UsedInTheseDefs) {
    Arr->RelationModifiedTag.Add( CurrRel );
}

class Thing {
    char* Name;
    HashTable<Thing*, int> Relationships;
    Set<Thing*> UnknownRelationships;
    ArrayDefinition* ArrayDef;
    Set<Thing*> CanAffect; // Thing where this in ArrayDefinition and UnknownRelationships not empty
}

class ArrayDefinition {
    Array<Thing> Items;
}

现在，如果我说T=R，那很好。但这并不影响X和Y之间的关系。因此，仅仅因为T和R的关系被称为“相等”，而在它可能完全未知之前，这并不意味着我需要再次比较X和Y

另一方面，如果我说“

T在E之外

”，这是用来定义两个数组的事物之间的关系。所以说“

T在E

之外”意味着我需要处理X的数组和Y的数组

我真的不想仅仅为了处理1000个阵列上的逻辑而比较500000个“阵列对”，因为它们之间几乎没有任何变化

所以。。。我第一次尝试简化它，是保留一个列表，其中列出了一个东西用来定义的所有数组

class Thing {
    char* Name;
    HashTable<Thing*, int> Relationships;
    ArrayDefinition* ArrayDef;
    Set<ArrayDefinition*> UsedInTheseDefs;
}

class ArrayDefinition {
    Array<Thing> Items;
    Set<int> RelationModifiedTag;
}

假设我有3个数组：

    A = [ X Y Z ]
    B = [ X X X X ]
    C = [ X Z X F ]

那么，X在3个数组中使用。因此，X可以保存一个它在其中使用的所有数组的列表

因此，如果我说

“Y中的X”

，这可能会列出Y用于定义的所有数组，以及X用于定义的所有数组。假设X在3个数组中使用，Y在1个数组中使用。由此，我们可以看出有两个“数组对”需要比较（A对B，A对C）

我们可以通过检查是否有任何数组对已经具有完全已知的关系来进一步修剪此列表

我的问题是，这似乎还是太过分了

假设X是一个非常普通的“东西”。它在10000个阵列中使用。Y是一个非常常见的东西，用于10000个数组

我仍然有100000000个数组对要比较。好吧，假设我不需要比较它们，实际上，只有50个部分已知或完全未知

但是。。。我仍然需要浏览100000000个数组对的列表，以找出其中哪些是部分已知的。所以它仍然是低效的

我真的很想知道是否没有有效的方法来做这件事。如果我真的能做的就是制定一些有效的“启发式”策略。我还没有太多的运气想出好的策略

我意识到这个问题是高度专业化的。我意识到阅读这篇长篇文章可能需要太长时间。我只是不知道如何缩短文章长度，或者用更常见的问题来描述这一点

如果有帮助的话。。。我最好用通用术语来表达这一点，就是“如何仅比较已更新的列表”

有人有什么想法吗？那太好了。如果不是。。。也许只要我把这些写出来就可以帮助我思考

问题是，我只是忍不住觉得有一些算法或方法可以让这个问题快速有效地运行。我只是不知道那个算法是什么

---

感谢大家

总的来说，您不可能为每项操作都尽可能快地设计出一个结构。需要做出权衡

---

这个问题看起来非常类似于在关系数据库上执行查询-

SELECT*WHERE…

。你可能会考虑寻找灵感。

我不确定我完全理解你在做什么（ArayDead的目的特别模糊），但是我认为你应该考虑把对象的模型与它们的关系分开。换句话说，为每个关系创建一个从对象到对象的单独映射。如果对象由其整数索引表示，则只需找到一种表示整数到整数映射的有效方法

我睡着了，醒来时，我有了一个新的想法。这可能有用

如果每个“东西”都保存了一个列表，其中列出了它用来定义的所有“数组定义”

class Thing {
    char* Name;
    HashTable<Thing*, int> Relationships;
    ArrayDefinition* ArrayDef;
    Set<ArrayDefinition*> UsedInTheseDefs;
}

class ArrayDefinition {
    Array<Thing> Items;
    Set<int> RelationModifiedTag;
}

我改变了双方的关系。因此，如果我这样做了：

“A在B之外”

，那么我将“modifiedtag”添加到所有用于定义A的数组中，而所有用于定义B的数组中

class Thing {
    char* Name;
    HashTable<Thing*, int> Relationships;
    ArrayDefinition* ArrayDef;
    Set<ArrayDefinition*> UsedInTheseDefs;
}

class ArrayDefinition {
    Array<Thing> Items;
    Set<int> RelationModifiedTag;
}

然后，我循环我的“可比较数组对”列表。每对当然是两个数组，每个数组都有一个“RelationModifiedTag”集合

所以我检查了两个RelationModifiedTag集合，看看它们是否有匹配的数字。如果他们这样做了，那么这意味着这个数组对有一个刚刚被改变的关系！所以然后我可以进行数组比较

它应该会起作用：）

它确实需要一些开销，但主要的是我认为它可以很好地扩展到更大的数据集。对于较小的数据集（例如只有10个数组），可以使用更简单、更暴力的方法，只需比较所有不具有完全已知关系的数组对，而不必费心跟踪更改了哪些关系

有可能进行进一步的优化。但我不会在这里讨论这些，因为它只是分散了对主要算法的注意力，而且它们是很明显的。例如，如果我有两个集合要比较，我应该在较小的集合上循环，并对照较大的集合进行检查

---

抱歉，我不得不读这么长的文字。谢谢你的帮助。

首先，我要介绍一些词汇

设计模式：

Observer

这是一种设计模式，允许对象将自己注册到其他对象中，并请求事件通知

例如，每个

ThingWithArray

都可以在他们管理的

ThingWithArray

中注册自己，这样如果

ThingWithArray

被更新，那么

ThingWithArray

将得到回复通知

现在，通常会有一个

取消订阅

me