计算满足给定条件的索引对

在编程中，我们经常需要计算满足给定条件的索引对。以下是一些常见的场景：

• 在数组中找到两个元素的和等于给定的目标值。
• 给定一个字符串，找到所有相邻子串中的回文对。
• 给定一个整数数组，计算所有差值等于给定值的索引对的数量。

这些问题可以使用不同的算法和数据结构来解决。以下是一些常见的方法：

暴力枚举

暴力枚举是一种朴素的方法，它涉及到对所有可能的索引对进行遍历并检查它们是否满足给定的条件。

例如，在数组中找到两个元素的和等于给定的目标值，可以使用两层循环来枚举所有可能的索引对，并检查它们的和是否等于目标值。

def twoSum(nums, target):
    n = len(nums)
    for i in range(n):
        for j in range(i + 1, n):
            if nums[i] + nums[j] == target:
                return [i, j]

暴力枚举的时间复杂度通常是 $O(n^2)$，在输入较大时可能会超时。因此，我们需要更高效的方法。

哈希表/字典

哈希表/字典是一种用于快速查找的数据结构，它将每个元素的键映射到它的值。在哈希表中查找一个元素的时间复杂度是常数时间 $O(1)$。

例如，在数组中找到两个元素的和等于给定的目标值，可以使用哈希表来存储每个元素的值和索引，然后遍历数组并检查每个元素是否存在一个补数（即目标值减去当前元素的值）。

def twoSum(nums, target):
    map = {}
    for i in range(len(nums)):
        complement = target - nums[i]
        if complement in map:
            return [map[complement], i]
        map[nums[i]] = i

在此示例中，我们使用哈希表将遍历数组仅一次的时间复杂度降低到 $O(n)$。

哈希表/字典还可以用于其他类似的问题，例如查找所有相邻子串中的回文对。

def palindromePairs(words):
    def isPalindrome(word):
        return word == word[::-1]

    # 构建字典，将每个单词的反转形式映射到其索引
    index = {word[::-1]: i for i, word in enumerate(words)}

    result = []
    for i, word in enumerate(words):
        n = len(word)
        for j in range(n + 1):
            # 将当前单词分解为左右两个子串
            left, right = word[:j], word[j:]

            # 如果左子串是回文，则查找右子串的反转形式是否存在
            if isPalindrome(left):
                if right[::-1] in index:
                    k = index[right[::-1]]
                    if k != i:
                        result.append([k, i])

            # 如果右子串是回文，则查找左子串的反转形式是否存在
            if j != n and isPalindrome(right):
                if left[::-1] in index:
                    k = index[left[::-1]]
                    if k != i:
                        result.append([i, k])

    return result

双指针

双指针是一种在已排序的数组或链表中快速查找一个元素或一个索引对的方法。它涉及到维护两个指针，一个指向数组/链表中的左端，另一个指向右端。

例如，在已排序的数组中找到两个元素的和等于给定的目标值，可以使用双指针，一个指向数组的左端，另一个指向右端。初始化时，左指针指向数组的起始位置，右指针指向数组的末端。我们计算两个指针所指的元素的和，并比较它与目标值的大小。

• 如果它们的和等于目标值，则我们已经找到了一个索引对。
• 如果它们的和小于目标值，则左指针向右移动一位。
• 如果它们的和大于目标值，则右指针向左移动一位。

def twoSum(nums, target):
    nums.sort()
    left, right = 0, len(nums) - 1
    while left < right:
        if nums[left] + nums[right] == target:
            return [left, right]
        elif nums[left] + nums[right] < target:
            left += 1
        else:
            right -= 1

在已排序的数组中使用双指针的时间复杂度是线性的 $O(n)$，因为我们在最坏情况下遍历整个数组。

双指针还可以用于其他类似的问题，例如在有序矩阵中查找一个元素。

def searchMatrix(matrix, target):
    if not matrix or not matrix[0]:
        return False

    # 初始化左指针和右指针
    m, n = len(matrix), len(matrix[0])
    left, right = 0, m * n - 1

    # 使用二分查找，将二维矩阵看作一维数组
    while left <= right:
        mid = (left + right) // 2
        x = matrix[mid // n][mid % n]
        if x == target:
            return True
        elif x < target:
            left = mid + 1
        else:
            right = mid - 1

    return False

总结

在编程中，计算满足给定条件的索引对是许多常见问题的关键部分。我们可以使用多种算法和数据结构来解决这些问题，包括暴力枚举、哈希表/字典和双指针。了解这些方法可以帮助你更有效地解决这些问题，并在编写高效程序时提供帮助。