LeetCode #532. K-diff Pairs in an Array 数组 哈希 双指针

Description

---

Given an array of integers and an integer k, you need to find the number of unique k-diff pairs in the array. Here a k-diff pair is defined as an integer pair (i, j), where i and j are both numbers in the array and their absolute difference is k.

Example 1:

Input: [3, 1, 4, 1, 5], k = 2
Output: 2
Explanation: There are two 2-diff pairs in the array, (1, 3) and (3, 5).
Although we have two 1s in the input, we should only return the number of unique pairs.

Example 2:

Input:[1, 2, 3, 4, 5], k = 1
Output: 4
Explanation: There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).

Example 3:

Input: [1, 3, 1, 5, 4], k = 0
Output: 1
Explanation: There is one 0-diff pair in the array, (1, 1).

Note:

• The pairs (i, j) and (j, i) count as the same pair.
• The length of the array won't exceed 10,000.
• All the integers in the given input belong to the range: [-1e7, 1e7].

思路

---

解法一

这道题暴力解法很简单，将元素两两组合变成一个pair，并用一个数组存储所有的 pair 以便查重。当然，在暴力解法 O(n^3) 的基础上，我们可以利用 HashMap 把第三层的数组给优化成 Hash 查询，从而将时间复杂度优化为 O(n^2)。

Hash 的策略是这样：如果我们假设 pair 中的第一个元素不大于第二个元素，那么我们使用第一个元素就能唯一标识一个 pair。

当然，该 Hash 策略说明了我们可以只使用 HashSet，能比 HashMap 少用一些空间，因为 HashMap 中键值对的值并没有什么用。

特别需要注意的是，这道题有个很恶心的坑点，即 K 可以小于 0，而题目中说了 k 表示两数的绝对值，很容易误导人（我就是这么被误导了....）。

时间复杂度：O(n^2)
空间复杂度：O(n)

耗时 1696 ms, faster than 5%, Memory 17.7 MB

class Solution {
public:
    int findPairs(const vector<int> &nums, int k) {
        if (nums.size() < 2) return 0;
        if (k < 0) return 0;  // absolute difference won't be negative

        int pair_num = 0;
        // a number can represent a pair
        // if the "first" of pair is always no more than the "second", like {2, 3}
        unordered_set<int> visited;

        for (int i = 0; i < nums.size() - 1; ++i) {
            for (int j = i + 1; j < nums.size(); ++j) {
                // Attention! k can be negative
                if (abs(nums[i] - nums[j]) == k) {
                    if (nums[i] <= nums[j]) {
                        // num[i] is the "first" in pair
                        if (visited.find(nums[i]) == visited.end()) {
                            visited.insert(nums[i]);
                            ++pair_num;
                        }
                    } else {
                        // num[j] is the "first" in pair
                        if (visited.find(nums[j]) == visited.end()) {
                            visited.insert(nums[j]);
                            ++pair_num;
                        }
                    }
                }
            }
        }

        return pair_num;
    }
};

解法二

更改一下 Hash 策略，key 还是各个数字，但是 value 变成了各个数字出现的次数。遍历一遍 nums 得到各个数字以及出现的次数后，可以遍历 map 中的所有键值对，使用 HashMap O(1) 的查找操作查找与当前间隔为 k 的数。

时间复杂度：O(n)
空间复杂度：O(n)

耗时 72 ms, faster than 30.7 %, Memory 18.4 MB

class Solution {
public:
    int findPairs(const vector<int> &nums, int k) {
        if (nums.size() < 2) return 0;
        if (k < 0) return 0;  // absolute difference won't be negative

        int pair_num = 0;
        // key is a number, value is frequency that the number appears
        unordered_map<int, int> m;

        for (int x : nums) {
            auto iter = m.find(x);
            if (iter != m.end()) {
                ++iter->second;
            } else {
                m[x] = 1;
            }
        }

        for (const auto &item : m) {
            if (k > 0) {
                if (m.count(item.first + k)) ++pair_num;
            } else if (k == 0) {
                if (item.second > 1) ++pair_num;
            }
        }

        return pair_num;
    }
};

解法三

参考博客中还提到了一种使用双指针的解法，在本题里它是一个时间换空间的策略，因为必须先进行 O(nlgn) 的排序保证序列的有序性，然后再求绝对值，否则就变成了暴力解法了。

我们知道解法一中，对于每一个序列 {a, b} 且 a <= b，我们可以使用 a 来唯一表示 {a, b}。那么排序做法的另一个好处是我们不再需要用于 pair 查重时所需的 O(n) 容器，在每一轮中只需要一个变量存储 pair 即可。

具体解法可以参考一下文章末尾贴出的博客。

时间复杂度：O(n^2) = 排序O(nlgn) + 双重扫描O(n^2)
空间复杂度：O(n)

参考

---

• [LeetCode] 532. K-diff Pairs in an Array 数组中差为K的数对