找到具有 O(1) 空间和 O(n) 时间的重复数字

Question

我正在用 leetcode 解决一个问题

给定一个包含 n + 1 个整数的数组 nums，其中每个整数都介于 1 和 n（含）之间，证明至少存在一个重复数。假设只有一个重复数，在O(n)时间和O(1)空间复杂度内找到重复的数

class Solution(object):
    def findDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        xor=0
        for num in nums:
            newx=xor^(2**num)
            if newx<xor:
                return num
            else:
                xor=newx

我接受了解决方案，但我被告知它既不是 O(1) 空间也不是 O(n) 时间。

谁能帮我理解为什么？

Answer 1

您的问题实际上很难回答。通常在处理复杂性时，有一个假定的机器模型。 A standard model 假设当输入大小为 n 时，内存位置的大小为 log(n) 位，并且对大小为 log(n) 位的算术运算为 O(1)。

在此模型中，您的代码在空间上不是 O(1)，在时间上不是 O(n)。您的 xor 值有 n 位，这不适合固定的内存位置（它实际上需要 n/log(n) 个内存位置。同样，它不是 O(n) 时间，因为算术运算已开启大于 log(n) 位的数字。

要在 O(1) 空间和 O(n) 时间内解决您的问题，您必须确保您的值不会变得太大。一种方法是对数组中的所有数字进行异或运算，然后您将得到1^2^3...^n ^ d，其中d 是重复的。因此，您可以对数组的总异或异或1^2^3^..^n，并找到重复值。

def find_duplicate(ns):
    r = 0
    for i, n in enumerate(ns):
        r ^= i ^ n
    return r

print find_duplicate([1, 3, 2, 4, 5, 4, 6])

这是 O(1) 空间和 O(n) 时间，因为 r 从未使用比 n 更多的位（即大约 ln(n) 位）。

Answer 2

您的解决方案不是 O(1) 空间，这意味着：您的空间/内存不是恒定，而是取决于输入！

newx=xor^(2**num)

这是对log_2(2**num) = num 位的按位异或，其中num 是您的输入数字之一，产生log_2(2**num) = num 位结果。

所以n=10 = log_2(2^10) = 10 bits，n=100 = log_2(2^100) = 100 bits。它呈线性增长（不是恒定的）。

它也不在你得到的 O(n) 时间复杂度内：

• 对所有 n 个数字的外循环
  • 和一个非常量/非 O(1) 内循环（见上文）
  • 假设：XOR 在输入的位表示方面不是恒定的
    • 并不总是这样处理；但物理学支持这一说法（钱德拉塞卡极限、光速……）

Answer 3

这个问题必须用链表弗洛伊德算法来解决。

将数组转换为链表。有 n+1 个位置，但只有 n 个值。

例如如果你有这个数组：[1,3,4,2,2] 将它转换为链表。

指点的工作原理

从索引 0 开始，查看该位置的哪个元素。它是 1。那么索引 0 将指向 nums1。 0 指向 3。然后找出 3 指向哪个值。这将是 nums[3] 等等。

现在您将其转换为链表，您必须使用 Floyd 的兔子和乌龟算法。基本上你有两个指针，慢的和快的。如果有循环，慢速指针和快速指针会在某个时间点相遇。

from typing import List
class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        # slow and fast are index
        slow,fast=0,0
        while True:
            slow=nums[slow]
            fast=nums[nums[fast]]
            if slow==fast:
                break
        # so far we found where slow and fast met.
        # to find where cycle starts we initialize another pointer from start, let's name is start
        # start and slow will move towards each other, and meeting point will be the point that you are looking for
        start=0
        while True:
            slow=nums[slow]
            start=nums[start]
            if slow==start:
                return slow

请注意，第一个索引之后的所有元素都不会指向索引 0 处的值。因为我们的范围是 1-n。我们正在跟踪我们通过 nums[value] 指向的位置，但由于没有值会是 0，所以没有任何东西会指向 nums[0]