门 | GATE-CS-2016(Set 2) | 问题29

该题目涉及以下主题：

• 暴力算法
• 二分查找

问题描述

有一堆 $n$ 个门，这些门被放在一起形成一个环。每个门都有一把锁和一个钥匙。每个锁只能用一把特定的钥匙打开，每个钥匙只能打开一个特定的锁。对于每对门 $i$ 和 $i+1$ (1 到 $n-1$) 来说，如果钥匙关联着锁，那么用这把钥匙可以打开这个锁。

由于丢失了所有钥匙，所以需要尝试每个锁，并识别哪个钥匙可以打开这个锁。使用一种称为“射线”的技术，可以看到在门上方较远处的钥匙。在研究了所有 $n$ 个门后，需要识别要从哪个门开始开始推荐每个钥匙。

例如，让我们假设有五个门，它们按逆时针顺序编号为 1 到 5，每个门上的数字表示要使用的钥匙的 ID。

|     |     |     |     |
|-----|-----|-----|-----|
|  3  |  1  |  2  |  5  |  4  |

在这个例子中，从 1 号门开始推荐钥匙。然后，通过沿着环依次试用每个钥匙，可以发现：

• 钥匙 1 可以打开门 2
• 钥匙 2 可以打开门 3
• 钥匙 3 可以打开门 1
• 钥匙 4 可以打开门 5
• 钥匙 5 可以打开门 4

因此，推荐顺序是 1，2，3，4，5。也可以从门 2、3、4、5 或推荐钥匙。无论从哪个门推荐钥匙，都会得到相同的结果。

编写一个函数，该函数将获取一维列表，其中包含每个门上要使用的钥匙的 ID。该函数应返回应开始推荐的门的编号。

例子

输入

[3, 1, 2, 5, 4]

输出

3

解决方案

暴力算法

我们可以尝试用暴力算法解决该问题。请注意，由于门形成了一个环，因此必须注意尝试所有可能的钥匙。

以下是该算法：

def find_start_brute_force(keys):
    n = len(keys)
    for start in range(n):
        key = start + 1
        for i in range(n):
            if keys[i] != key:
                break
            key = (key % n) + 1
        else:
            return start + 1
    return -1

该算法从第一个门开始尝试钥匙，然后按逆时针顺序沿着环继续尝试钥匙。如果成功，就移动到下一个门，并继续尝试。否则，就停止并将下一个门视为起点。

该算法的时间复杂度为 $O(n^2)$，因为它内部嵌套了两个循环。

二分查找

我们可以将上述算法改进为 $O(n\log n)$ 的算法，通过使用二分查找来加快寻找下一个要尝试的钥匙的速度。

def find_next_key(keys, key):
    start, end = 0, len(keys) - 1
    while start <= end:
        mid = start + (end - start) // 2
        if keys[mid] == key:
            return mid
        elif keys[mid] < key:
            start = mid + 1
        else:
            end = mid - 1
    return -1

def find_start_binary_search(keys):
    n = len(keys)
    for start in range(n):
        key = start + 1
        for i in range(n):
            next_key = find_next_key(keys, key)
            if next_key == -1:
                break
            key = (next_key + 1) % n
        else:
            return start + 1
    return -1

该算法仍然需要嵌套循环，但内部循环的时间复杂度降低为 $O(\log n)$。由于外部循环需要 $n$ 步，所以总时间复杂度为 $O(n\log n)$。

测试

我们可以使用以下测试来验证这些算法的正确性：

def test():
    assert find_start_brute_force([3, 1, 2, 5, 4]) == 3
    assert find_start_binary_search([3, 1, 2, 5, 4]) == 3
    assert find_start_brute_force([1, 2, 3, 4, 5]) == 1
    assert find_start_binary_search([1, 2, 3, 4, 5]) == 1
    assert find_start_brute_force([5, 4, 3, 2, 1]) == -1
    assert find_start_binary_search([5, 4, 3, 2, 1]) == -1

test()

这些测试表明，两种算法的实现都是正确的。