在多个数组中查找序列号的有效方法？
Efficient way of finding sequential numbers across multiple arrays?
我不是在寻找任何代码或为我做任何事情。我需要一些帮助才能朝着正确的方向开始，但不知道如何去做。如果有人可以提供一些有关如何解决这些问题的资源，我将不胜感激。我一直坐在我的笔记本电脑前，但在设计一种可以完成我想做的事情的算法时遇到了麻烦。
我大概能做到：
foreach element in array1
foreach element in array2
check if array1[i] == array2[j]+x
我相信这对前向和后向序列都有效，对于倍数只需检查 array1[i] % array2[j] == 0。我有一个包含 int 数组的列表，并且正在获取 list[index]（对于 array1）和 list[index+1] 对于 array2，但是此解决方案可能会变得复杂而冗长，尤其是对于大数组和这些数组的大量列表。因此，我正在寻找更好的解决方案。
我正在尝试提出一种算法来查找不同数组中的序号。
例如：
[1, 5, 7] 和 [9, 2, 11] 会发现 1 和 2 是连续的。
这也适用于多个数组中的多个序列。因此，如果存在 [24, 3, 15] 的第三个数组，它也会在该序列中包含 3，并继续到下一个数组，直到没有与 last sequential element + 1 匹配的数字为止。
它也应该能够在数组之间找到一个以上的序列。
例如：
[1, 5, 7] 和 [6, 3, 8] 会发现 5 和 6 是连续的，并且 7 和 8 也是连续的。
我也对查找反向序列感兴趣。
例如：
[1, 5, 7]和[9, 4, 11]将return5和4倒序。
全部示例：
[1, 5, 8, 11]和[2, 6, 7, 10]会return1和2是连续的，5和6是连续的， 8和7是反序的，11和10是反序的。
也可以重叠：
[1, 5, 7, 9] 和 [2, 6, 11, 13] 将 return 1 和 2 顺序，5 和 6 顺序以及 7 和 6 反向顺序。
我还想扩展它以检查相差 x 的数字（以上示例检查相差 1）。
除了所有这些（虽然这可能是一个不同的问题），我还想检查倍数，
示例：
[5, 7, 9] 和 [10, 27, 8] 将 return 5 和 10 作为倍数，9 和 27 作为倍数。
和相同位置的数字。
示例：
[3, 5, 7] 和 [13, 23, 25] 将 return 3 和 13 和 23 具有相同的个位。
您的伪代码中概述的蛮力方法将是 O(c^n)（指数），其中 c 是每个数组的平均元素数，n 是总数组数.
如果输入 space 是 sparse（意味着平均缺失的数字会多于呈现的数字），那么加快此过程的一种方法是首先创建一组来自所有不同数组的所有唯一数字的排序集。此 "master" 集将允许您在任何不可行的序列上提前退出（即循环中的 break 语句）。
例如，如果我们有输入数组 [1, 5, 7] 和 [6, 3, 8] 以及 [9, 11, 2]，则主有序集将为 {1, 2, 3, 5, 6, 7, 8, 9, 11}。如果我们正在寻找 n+1 类型的序列，我们可以跳过 continuing 检查任何包含 3 或 9 或 [=21= 的序列]（因为 n+1 值不存在于排序集中的下一个索引中。虽然在这个特定示例中加速并不剧烈，但如果您有数百个输入数组和非常大范围的值 n（稀疏性），那么加速应该是指数级的，因为您将能够提前退出许多排列。如果输入 space 不是稀疏的（例如在这个例子中我们没有很多洞） ，加速将小于指数。
进一步的改进是存储一组 "master" 键值对，其中键是上面示例中所示的 n 值，以及该对的值部分是包含该值的任何数组的索引列表。上一个示例的主集将是：{[1, 0], [2, 2], [3, 1], [5, 0], [6, 1], [7, 0], [8, 1], [9, 2], [11, 2]}。使用这种架构，扫描时间可能会低至 O(c*n)，因为您可以遍历这个单一排序的主集来寻找有效序列，而不是遍历所有子数组。通过还要求数组索引递增，您可以清楚地看到可以跳过 1->2 序列，因为数组的顺序不正确，与 2->3 序列等相同。注意这一点玩具示例有点过于简单，因为在实践中您需要键值对的值部分的索引列表。如果 n 的相同值曾出现在多个数组（重复值）中，则这是必要的。
使用字典（set 或 hashmap）
dictionary1 = {}
遍历第一个数组中的每一项并将其添加到字典中。
[1, 5, 7]
现在dictionary1 = {1:true, 5:true, 7:true}
dictionary2 = {}
现在检查 [6, 3, 8] 中的每个项目并查找它是否是序列的一部分。
6 是序列的一部分，因为 dictionary1[6+1] == true
所以 dictionary2[6] = true
我们得到dictionary2 = {6:true, 8:true}
现在设置dictionary1 = dictionary2和dictionary2 = {}，然后转到第三个数组..依此类推
我们只跟踪序列。
由于每次查找都是 O(1)，并且我们对每个数字进行 2 次查找（例如 6-1 和 6+1），因此总数为 n*O(1)，即 O(N)（N 是数字的数量在所有数组中）。
我不是在寻找任何代码或为我做任何事情。我需要一些帮助才能朝着正确的方向开始，但不知道如何去做。如果有人可以提供一些有关如何解决这些问题的资源，我将不胜感激。我一直坐在我的笔记本电脑前，但在设计一种可以完成我想做的事情的算法时遇到了麻烦。
我大概能做到：
foreach element in array1
foreach element in array2
check if array1[i] == array2[j]+x
我相信这对前向和后向序列都有效，对于倍数只需检查 array1[i] % array2[j] == 0。我有一个包含 int 数组的列表，并且正在获取 list[index]（对于 array1）和 list[index+1] 对于 array2，但是此解决方案可能会变得复杂而冗长，尤其是对于大数组和这些数组的大量列表。因此，我正在寻找更好的解决方案。
我正在尝试提出一种算法来查找不同数组中的序号。
例如：
[1, 5, 7] 和 [9, 2, 11] 会发现 1 和 2 是连续的。
这也适用于多个数组中的多个序列。因此，如果存在 [24, 3, 15] 的第三个数组，它也会在该序列中包含 3，并继续到下一个数组，直到没有与 last sequential element + 1 匹配的数字为止。
它也应该能够在数组之间找到一个以上的序列。
例如：
[1, 5, 7] 和 [6, 3, 8] 会发现 5 和 6 是连续的，并且 7 和 8 也是连续的。
我也对查找反向序列感兴趣。
例如：
[1, 5, 7]和[9, 4, 11]将return5和4倒序。
全部示例：
[1, 5, 8, 11]和[2, 6, 7, 10]会return1和2是连续的，5和6是连续的， 8和7是反序的，11和10是反序的。
也可以重叠：
[1, 5, 7, 9] 和 [2, 6, 11, 13] 将 return 1 和 2 顺序，5 和 6 顺序以及 7 和 6 反向顺序。
我还想扩展它以检查相差 x 的数字（以上示例检查相差 1）。
除了所有这些（虽然这可能是一个不同的问题），我还想检查倍数，
示例：
[5, 7, 9] 和 [10, 27, 8] 将 return 5 和 10 作为倍数，9 和 27 作为倍数。
和相同位置的数字。
示例：
[3, 5, 7] 和 [13, 23, 25] 将 return 3 和 13 和 23 具有相同的个位。
您的伪代码中概述的蛮力方法将是 O(c^n)（指数），其中 c 是每个数组的平均元素数，n 是总数组数.
如果输入 space 是 sparse（意味着平均缺失的数字会多于呈现的数字），那么加快此过程的一种方法是首先创建一组来自所有不同数组的所有唯一数字的排序集。此 "master" 集将允许您在任何不可行的序列上提前退出（即循环中的 break 语句）。
例如，如果我们有输入数组 [1, 5, 7] 和 [6, 3, 8] 以及 [9, 11, 2]，则主有序集将为 {1, 2, 3, 5, 6, 7, 8, 9, 11}。如果我们正在寻找 n+1 类型的序列，我们可以跳过 continuing 检查任何包含 3 或 9 或 [=21= 的序列]（因为 n+1 值不存在于排序集中的下一个索引中。虽然在这个特定示例中加速并不剧烈，但如果您有数百个输入数组和非常大范围的值 n（稀疏性），那么加速应该是指数级的，因为您将能够提前退出许多排列。如果输入 space 不是稀疏的（例如在这个例子中我们没有很多洞） ，加速将小于指数。
进一步的改进是存储一组 "master" 键值对，其中键是上面示例中所示的 n 值，以及该对的值部分是包含该值的任何数组的索引列表。上一个示例的主集将是：{[1, 0], [2, 2], [3, 1], [5, 0], [6, 1], [7, 0], [8, 1], [9, 2], [11, 2]}。使用这种架构，扫描时间可能会低至 O(c*n)，因为您可以遍历这个单一排序的主集来寻找有效序列，而不是遍历所有子数组。通过还要求数组索引递增，您可以清楚地看到可以跳过 1->2 序列，因为数组的顺序不正确，与 2->3 序列等相同。注意这一点玩具示例有点过于简单，因为在实践中您需要键值对的值部分的索引列表。如果 n 的相同值曾出现在多个数组（重复值）中，则这是必要的。
使用字典（set 或 hashmap）
dictionary1 = {}
遍历第一个数组中的每一项并将其添加到字典中。
[1, 5, 7]
现在dictionary1 = {1:true, 5:true, 7:true}
dictionary2 = {}
现在检查 [6, 3, 8] 中的每个项目并查找它是否是序列的一部分。
6 是序列的一部分，因为 dictionary1[6+1] == true
所以 dictionary2[6] = true
我们得到dictionary2 = {6:true, 8:true}
现在设置dictionary1 = dictionary2和dictionary2 = {}，然后转到第三个数组..依此类推
我们只跟踪序列。 由于每次查找都是 O(1)，并且我们对每个数字进行 2 次查找（例如 6-1 和 6+1），因此总数为 n*O(1)，即 O(N)（N 是数字的数量在所有数组中）。