Count the Number of Fair Pairs

Count the Number of Fair Pairs

Given a 0-indexed integer array nums of size n and two integers lower and upper , return the number of fair pairs.

A pair (i, j) is fair if:

• 0 <= i < j < n , and
• lower <= nums[i] + nums[j] <= upper 

Example 1:

Input: nums = [0,1,7,4,4,5], lower = 3, upper = 6
Output: 6
Explanation: There are 6 fair pairs: (0,3), (0,4), (0,5), (1,3), (1,4), and (1,5).

Example 2:

Input: nums = [1,7,9,2,5], lower = 11, upper = 11
Output: 1
Explanation: There is a single fair pair: (2,3).

Constraints:

• $1 \leq \text{nums.length} \leq {10}^{5}$
• $\text{nums.length} \ \mathrm{==} \ n$
• $-10^9 \leq \text{nums}[i] \leq 10^9$
• $-10^9 \leq \text{lower} \leq \text{upper} \leq 10^9$

 

解题思路

　　枚举$i$，然后在$0 \leq j < i$中统计有多少个$j$满足$\text{lower} - \text{nums}[i] \leq \text{nums}[j] \leq \text{upper} - \text{nums[i]}$，这个还是很容易想到的。比赛的时候没有想到简单的做法，硬是写了个离散化加树状数组过了。

　　AC代码如下：

const int N = 3e5 + 10;

int xs[N], sz;
int tr[N];

int lowbit(int x) {
    return x & -x;
}

void add(int x, int c) {
    for (int i = x; i <= sz; i += lowbit(i)) {
        tr[i] += c;
    }
}

int query(int x) {
    int ret = 0;
    for (int i = x; i; i -= lowbit(i)) {
        ret += tr[i];
    }
    return ret;
}

int find(int x) {
    int l = 1, r = sz;
    while (l < r) {
        int mid = l + r >> 1;
        if (xs[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return l;
}

class Solution {
public:
    long long countFairPairs(vector<int>& nums, int lower, int upper) {
        int n = nums.size();
        sz = 0;
        for (int i = 0; i < n; i++) {
            xs[++sz] = nums[i];
            xs[++sz] = lower - nums[i];
            xs[++sz] = upper - nums[i];
        }
        sort(xs + 1, xs + sz + 1);
        sz = unique(xs + 1, xs + sz + 1) - xs - 1;
        memset(tr, 0, sizeof(tr));
        long long ret = 0;
        for (int i = 1; i < n; i++) {
            add(find(nums[i - 1]), 1);
            ret += query(find(upper - nums[i])) - query(find(lower - nums[i]) - 1);
        }
        return ret;
    }
};

　　我一直想着这才第二题怎么会这么复杂，实际上还是有简单写法的，就是没想到。

　　主要是是$j < i$这个条件限制，如果没有这个限制，直接问有多少个$j$满足$\text{lower} - \text{nums}[i] \leq \text{nums}[j] \leq \text{upper} - \text{nums[i]}$，那么就可以对$\text{nums}$数组排序然后二分。而实际上是可以直接忽略这个限制来二分，最后答案除以$2$就好了。

　　当枚举到$i$，如果存在$j > i$并且满足上述的不等式，那么是肯定可以二分到$\text{nums}[j]$。然后当枚举到了$j$，之前的$i < j$并且满足不等式，一样可以可以二分到$\text{nums}[i]$。所以如果存在$j < i$且满足$\text{lower} \leq \text{nums[i]} + \text{nums}[j] \leq \text{upper}$，若不考虑$j < i$这个条件来二分，数对是会被累计两次，所以最后答案除以$2$就可以了。

　　还需要注意的是，当枚举到$i$如果有$\text{lower} \leq \text{nums[i]} \leq \text{upper}$，那么会二分到$\text{nums}[i]$，这就需要减去这个情况了。

　　AC代码如下：

class Solution {
public:
    long long countFairPairs(vector<int>& nums, int lower, int upper) {
        nums.push_back(2e9 + 1);    // 加哨兵，保证可以二分到答案
        int n = nums.size();
        sort(nums.begin(), nums.end());
        long long ret = 0;
        function<int(int x)> find = [&](int x) {
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (nums[mid] >= x) r = mid;
                else l = mid + 1;
            }
            return l;
        };
        for (int i = 0; i < n - 1; i++) {
            int l = lower - nums[i], r = upper - nums[i];
            ret += find(r + 1) - find(l);
            if (nums[i] >= l && nums[i] <= r) ret--;
        }
        return ret / 2;
    }
};

 

参考资料

　　【LitteXi】统计公平数对的数目：https://leetcode.cn/problems/count-the-number-of-fair-pairs/solution/littexi-tong-ji-gong-ping-shu-dui-de-shu-n27n/