确定性线性时间算法，用于检查一个数组是否为另一个数组的排序版本

考虑以下问题：

输入：两个数组和的长度为，其中按排序顺序。 $A$ $B$ $n$ $B$

查询：做和包含相同的项目（与它们的多样性）？ $A$ $B$

解决此问题最快的确定性算法是什么？
能比排序更快解决吗？这个问题可以在确定的线性时间内解决吗？

algorithms reference-request sorting

FWIW概率方法是使用与顺序无关的哈希函数进行哈希。卡特和韦格曼（Carter and Wegman）撰写了有关此内容的原始论文之一（sciencedirect.com/science/article/pii/0022000081900337），但是在该论文的引文中我没有看到任何暗示确定性算法的内容（到目前为止）。

— KWillets

您引用的陈述是关于Turing机器模型的，仅具有理论意义。通常针对RAM模型来分析算法。

— Yuval Filmus

啊，那就是我要寻找的模型。我调整了问题。

— 阿尔伯特·亨德里克斯

您为什么不只对数组中的项求和，然后比较求和？关于您的标题，它是线性的，回答问题“一个数组是其他数组的排序版本吗？'。我知道这不是图灵机模型，而是实用的解决方案。

— atayenel

@AlbertHendriks您（很可能）无法在图灵机上以

O (n \log n)

$O(n\log n)$ 对数组进行排序。SAT的一些下限（例如cs.cmu.edu/~ryanw/automated-lbs.pdf）实际上是针对RAM机器的，对于我先前的误导性评论深表歉意。

— Yuval Filmus

Answers:

您尚未指定计算模型，因此我将假设为比较模型。

考虑其中阵列的特殊情况下从列表中取出换句话说，第个元素是或。 $B$

{1, 2} \times {3, 4} \times \dots \times {2 n - 1, 2 n} .

$\{1,2\} \times \{3,4\} \times \cdots \times \{2n-1,2n\}.$

i

$i$

2 i - 1

$2i-1$

2 i

$2i$

我声称，如果该算法得出的结论是和包含相同的元素，则该算法已将每个元素与其在对应元素进行了。确实，假设算法得出的结论是和包含相同的元素，但从未将的第一个元素与其对应元素进行比较。如果我们切换第一个元素，则算法将以完全相同的方式进行，即使答案不同。这表明算法必须将第一个元素（和任何其他元素）与其在对应元素进行。 $A$ $B$ $B$ $A$ $A$ $B$ $B$ $A$ $A$

这意味着，如果和包含相同的元素，则在验证了这一点之后，算法便知道的排序顺序。因此，它必须至少具有不同的叶子，因此需要时间。 $A$ $B$ $A$ $n!$ $\Omega(n\log n)$

— Yuval Filmus
source

我以为这通常意味着

，但是显然比较模型与此不同。

P = Ω (n \log n)

$P = \Omega(n\log n)$

— 艾伯特·亨德里克斯

@AlbertHendriks，它是用于显示用于排序的下限的同一模型。这意味着它唯一可以执行的操作就是比较，然后就无法做得更好。我认为这回答了您的问题。

— 卡夫

[Cntd]即使排序，我们也没有更强的界限！如果您可以比n lg n更快地排序，那么您可以使用它比n lg n更快地解决问题。

— 卡夫

@AlbertHendriks，您知道用于对整数进行排序的线性时间算法吗？在CLRS中查找。您的情况可能是我们可以按线性时间排序的情况之一。

— 卡夫

整型可以进行排序

（见nada.kth.se/~snilsson/fast-sorting），或在预期时间

O (n \log \log n)

$O(n\log\log n)$

（请参见ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=1181890），或者如果单词大小足够大，甚至可以在线性时间内（请参见LNCS 8503，第26ff页）。

O (n \sqrt{\log \log n})

$O(n\sqrt{\log\log n})$

— Yuval Filmus

这个答案考虑了一个不同的计算模型：单位成本RAM模型。在此模型中，机器字的大小为，对其进行的操作需要时间。为了简单起见，我们还假设每个数组元素都适合一个机器字（因此，大小最多为）。 $O(\log n)$ $O(1)$ $n^{O(1)}$

我们将构建一个单边误差的线性时间随机算法（即使不是这种情况，该算法也可能会声明两个数组包含相同的元素），这是确定两个数组是否更困难的问题。和包含相同的元素。（我们不需要对它们中的任何一个进行排序。）我们的算法将以最大概率产生错误。 $a_1,\ldots,a_n$ $b_1,\ldots,b_n$ $1/n$

这个想法是，下面的身份保持当且仅当阵列包含相同的元素：准确地计算这些多项式将花费太多时间。相反，我们选择一个随机素数和随机和测试是否

\prod_{i = 1}^{n} (x - a_{i}) = \prod_{i = 1}^{n} (x - b_{i}) .

$\prod_{i=1}^n (x-a_i) = \prod_{i=1}^n (x-b_i).$

p

$p$

x_{0}

$x_0$

如果数组相等，则测试将始终通过，因此让我们集中讨论数组不同的情况。特别地，一些系数

是非零的。由于

大小为

，因此该系数的大小为

\prod_{i = 1}^{n} (x_{0} - a_{i}) \equiv \prod_{i = 1}^{n} (x_{0} - b_{i}) (\mod p) .

$\prod_{i=1}^n (x_0-a_i) \equiv \prod_{i=1}^n (x_0-b_i) \pmod{p}.$

\prod_{i = 1}^{n} (x - a_{i}) - \prod_{i = 1}^{n} (x - b_{i})

$\prod_{i=1}^n (x-a_i) - \prod_{i=1}^n (x-b_i)$

a_{i}, b_{i}

$a_i,b_i$

n^{O (1)}

$n^{O(1)}$

，因此它最多具有

大小的素因数。这意味着，如果我们选择了一组至少

素数

的大小至少

（说），然后随机的质

这套它将概率至少持有

说

2^{n} n^{O (n)} = n^{O (n)}

$2^n n^{O(n)} = n^{O(n)}$

O (n)

$O(n)$

Ω (n)

$\Omega(n)$

n^{2}

$n^2$

p

$p$

n^{2}

$n^2$

p

$p$

1 - 1 / n

$1-1/n$

随机

模

将与概率见证这

（由于多项式度至多

具有至多

根）。

\prod_{i = 1}^{n} (x - a_{i}) - \prod_{i = 1}^{n} (x - b_{i}) ≢ 0 (\mod p) .

$\prod_{i=1}^n (x-a_i) - \prod_{i=1}^n (x-b_i) \not\equiv 0 \pmod{p}.$

x_{0}

$x_0$

p

$p$

1 - n / p \geq 1 - 1 / n

$1-n/p \geq 1-1/n$

n

$n$

n

$n$

总之，如果我们在至少不同素数的集合中选择大小约为的随机以及模的随机数，那么当数组不包含相同元素时，我们的测试将失败概率。由于符合恒定数量的机器字，因此运行测试需要时间。 $p$ $n^2$ $n^2$ $x_0$ $p$ $1-O(1/n)$ $O(n)$ $p$

使用多项式时间素数测试，并且由于大小约为的素数的密度为，因此我们可以选择时间上随机的素数。选择随机模可以通过多种方式实现，并且变得更容易，因为在我们的情况下，我们不需要完全均匀的随机。 $n^2$ $\Omega(1/\log n)$ $p$ $(\log n)^{O(1)}$ $x_0$ $p$ $x_0$

总之，我们的算法在时间运行，如果数组包含相同的元素，则始终输出YES，如果数组不包含相同的元素，则以概率输出NO 。对于任何常数我们都可以将错误概率提高到。 $O(n)$ $1-O(1/n)$ $1-O(1/n^C)$ $C$

— Yuval Filmus
source

虽然该算法是随机的，但它说明了如何在其他一些答案中实施这些构想，以使它们真正起作用。与哈希表方法相比，它还有一个优点：它是就地的。

— Yuval Filmus

我认为OP不喜欢概率算法，因为他不喜欢使用哈希表的预期线性时间算法。

— 卡夫

卡夫，你是对的。但是，当然，此解决方案也很有趣，应该保留下来，它解决了概率算法的情况。另外，我认为它使用了我正在寻找的模型。

— 艾伯特·亨德里克斯

我只是想知道符号O（1 / n）是否正确。当然，我知道您的意思，但是我认为通过big-O的定义，它等同于O（1）。

— 艾伯特·亨德里克斯

一点也不。对于一个足够大的

这是一个以

为边界的量。这比

更好。

C / n

$C/n$

n

$n$

O (1)

$O(1)$

— Yuval Filmus

-3

我将提出另一种算法（或至少是这种算法的一种方案）

该方案假定值（假定为“ 整数 ”）在之间的（狭窄？）范围内。 $[min,max]$

在时间扫描两个数组时，我们可以找到两个的和值以及它们的多重性，如果它们不同，则这两个数组不是彼此置换的 $O(n)$ minmax
min从两个数组的所有值中减去（此处未考虑一个数组已经按排序顺序排列的事实，想必可以对此进行改进）
假设数组中的值代表质量，我们对大小为每个应用加速度/速度（在某些情况下，可以将大小提高为） $1$ $c > 1$
移动质量直到达到最大值max-min，复杂度为。这样就可以找到相同的值和它们的多重性，如果它们不同，则数组不是彼此置换。否则，确定数组是彼此置换的。 $O((max-min)n)$

注意，在许多实际情况下，上述算法方案可以（确定性地）非常快。

上面的算法方案是采用“ 运动质量 ” 的线性时间排序算法的变体。“ 移动质量 ”排序算法背后的物理直觉是：

假设每个项目的值实际上代表其质量大小，并想象将所有项目排列成一条线并施加相同的加速力。

然后，每个项目将向上移动到与其质量相关的距离，而质量会减小，而反之亦然。然后，要检索已排序的项目，只需按行进距离的相反顺序收集项目即可。

$max-min$

在这方面，上述算法类似于基于数字的排序算法（例如，基数排序，计数排序）

可能有人认为这种算法可能意义不大，但它至少显示出一件事。从根本上说，从根本上说，“ 基本性 ”对任意数字进行排序是项数线性时间运算。

— Nikos M.
source

In terms of collecting the items in reverse order of distance travelled, wouldn't that translate to comparisons at the implementation level, and at that point do you not have to sort the "distances"?

— JustAnotherSoul