理解为什么弗洛伊德的龟兔赛跑算法在应用于整数数组时有效

Question

我试图解决这个 leetcode 问题https://leetcode.com/problems/find-the-duplicate-number/，使用我自己的龟兔算法实现，当给定以下整数数组时，会导致无限循环：

[3,1,3,4,2]

只有在跟踪我的算法后，我才能看到慢跑者和快跑者永远不会同时接受两个重复值。这是我的伪代码算法：

initialize fast and slow runners to 0

while(true)

   move fast runner two indices forward
   move slow runner one index forward

   if arr[fast] == arr[slow] and fast != slow
      return arr[fast] // this is the duplicate

现在，我确信精通离散数学的人能够直观地知道，如果不首先像我必须做的那样追溯一个示例，这种方法不会导致正确的解决方案。

我可以做出哪些推论或观察来让我看到这个算法不起作用？我想知道如何通过一系列逻辑语句直观地识别此逻辑中的缺陷。换句话说，为什么这两个跑步者永远不会在这个例子中找到重复项的解释是什么？我觉得这可能与计数有关，但我在离散方面没有很强的背景。

为了澄清，我已经查看了正确的实现，所以我知道解决它的正确方法是什么。我只是认为这种方式与将其应用于链表太相似了，在链表中，您可以将快跑者上移两个节点，将慢跑者上移一个节点。感谢您的帮助。

Answer 1

当您在链表中检测循环时，弗洛伊德的乌龟算法会起作用。它依赖于这样一个事实，即如果两个指针以不同的速度移动，它们之间的差距将不断增加到一个极限，之后如果存在循环，它将被重置。
在这种情况下，算法确实找到了一个循环，因为两个指针在一些迭代后都收敛到索引 0。但是，您不想在这里检测循环；您正在尝试查找重复项。这就是它陷入无限递归的原因：它旨在检测一个循环（它正确地做到了），但在其基本实现中不检测重复。

为了澄清，这里是在您的示例数组上创建的示例链表。

3 -> 1 -> 3 -> 4 -> 2
'--<----<----<----<-'

如果您运行 Floyd 算法，您会发现循环将在索引 0 处被检测到，因为两个指针都会在那里收敛。它通过检查fast 和slow 是否指向相同位置 而不是它们是否具有相同的节点值（fast==slow 与fast.value==slow.value 不同）来工作。

您正在尝试通过比较节点上的值来检查重复项，并检查节点是否指向同一位置。这实际上是一个缺陷，因为 Floyd 的算法会检查两个指针​​是否指向同一位置以检测循环。
您可以阅读this simple, informative proof 以提高您对指针为何会收敛的直觉。

Answer 2

这不是一个坏主意。这是 Python 中的一个实现：

class Solution:
    def findDuplicate(self, nums):
        slow, fast = 0, 0
        while True:
            slow = nums[nums[slow]]
            fast = nums[fast]
            if slow == fast:
                break

        fast = 0
        while True:
            slow, fast = nums[slow], nums[fast]
            if slow == fast:
                break
        return slow

我们也可以使用二分搜索：

class Solution:
    def findDuplicate(self, nums):
        lo, hi = 0, len(nums) - 1
        mid = lo + (hi - lo) // 2
        while hi - lo > 1:
            count = 0
            for num in nums:
                if mid < num <= hi:
                    count += 1
            if count > hi - mid:
                lo = mid
            else:
                hi = mid
            mid = lo + (hi - lo) // 2
        return hi

在 C++ 中：

// The following block might slightly improve the execution time;
// Can be removed;
static const auto __optimize__ = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    return 0;
}();


// Most of headers are already included;
// Can be removed;
#include <iostream>
#include <cstdint>
#include <vector>


static const struct Solution {
    static const int findDuplicate(
        const std::vector<int>& nums
    ) {
        int slow = 0;
        int fast = 0;

        while (true) {
            slow = nums[nums[slow]];
            fast = nums[fast];

            if (slow == fast) {
                break;
            }
        }

        fast = 0;

        while (slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }

        return slow;
    }
};