在数组中查找重复的数字

Question

我正在调试以下问题并发布我正在调试和研究的解决方案，解决方案或类似的解决方案已发布在几个论坛上，但我认为当 num[0] = 0 或一般 num 时解决方案存在错误[x] = x？我对么？如果我错了，请随时纠正我。

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

注意： 您不得修改数组（假设数组是只读的）。 您必须只使用常量，O(1) 额外空间。 您的运行时复杂度应小于 O(n2)。 数组中只有一个重复数，但可以重复多次。

int findDuplicate3(vector<int>& nums)
{
    if (nums.size() > 1)
    {
        int slow = nums[0];
        int fast = nums[nums[0]];
        while (slow != fast)
        {
            slow = nums[slow];
            fast = nums[nums[fast]];
        }

        fast = 0;
        while (fast != slow)
        {
            fast = nums[fast];
            slow = nums[slow];
        }
        return slow;
    }
    return -1;
}

Answer 1

从 1 到 N 的整数之和 = (N * (N + 1)) / 2。您可以使用它来查找重复项 - 将数组中的整数相加，然后从总和中减去上述公式。那是副本。

更新：上述解决方案基于（可能无效）假设输入数组由从 1 到 N 的值加上单个副本组成。

Answer 2

下面是我的代码，它使用了弗洛伊德的循环寻找算法：

#include <iostream>
#include <vector>
using namespace std;

int findDup(vector<int>&arr){
    int len = arr.size();
    if(len>1){
        int slow = arr[0];
        int fast = arr[arr[0]];
        while(slow!=fast){
            slow = arr[slow];
            fast = arr[arr[fast]];
        }
        fast = 0;
        while(slow!=fast){
            slow = arr[slow];
            fast = arr[fast];
        }
        return slow;
    }
    return -1;
}

int main() {
    vector<int>v = {1,2,2,3,4};
    cout<<findDup(v)<<endl;
    return 0;
}

评论这是因为不允许使用零，所以数组的第一个元素不是循环的一部分，因此我们找到的第一个循环的第一个元素同时引用循环内外。如果允许零，如果 arr[0] 在一个循环中，这将失败。例如，[0,1,1]。

Answer 3

由于您不能使用任何额外的空间，因此将排除使用另一个哈希表。

现在，谈到对现有数组进行散列的方法，如果允许我们就地修改数组，就可以实现。

算法：

1) 从第一个元素开始。

2) 散列第一个元素并对散列的值应用一个变换。假设这个变换使值 -ve。

3)继续下一个元素。对元素进行哈希处理，在应用转换之前，检查是否已经应用了转换。

4) 如果是，则元素是重复的。

代码：

 for(i = 0; i < size; i++)
  {
    if(arr[abs(arr[i])] > 0)
      arr[abs(arr[i])] = -arr[abs(arr[i])];
    else
      cout<< abs(arr[i]) <<endl;
  }  

这种转换是必需的，因为如果我们要使用散列方法，那么在散列相同的键时必须存在冲突。

我想不出一种可以在没有任何额外空间且不修改数组的情况下使用散列的方法。

Answer 4

1. 从指向第一个元素的两个指针开始：fast 和 slow。
2. 将“移动”定义为 fast 增加 2 步（位置）和 slow 增加 1。
3. 每次move后，检查slow和fast是否指向同一个节点。
4. 如果有一个循环，在某些时候他们会。这是因为在它们都进入循环之后，fast 的移动速度是 slow 的两倍，并且最终会“撞上”它。
5. 假设他们在 k 次移动 之后相遇。这不一定是重复元素，因为它可能不是从循环外部到达的循环的第一个元素。
   将此元素称为 X。
6. 请注意，fast 已步进 2k 次，slow 已步进 k 次。
7. 将快移回零。
8. 重复fast和slow每一步，在每一步之后进行比较。
9. 请注意，在另一个 k 步之后，slow 将总共移动 2k 步，fast 总共移动 k 从头开始​​，所以它们都将再次指向 X。
10. 请注意，如果前面的步骤对它们两个都在循环中，那么它们都指向 X-1。如果前面的步骤仅在 slow 的循环中，则它们指向不同的元素。
11. X-2、X-3、...
同上
12. 因此，在接下来的过程中，它们第一次指向同一个元素是从循环外部到达的第一个循环元素，也就是您要查找的重复元素。