leetcode——第 72 场双周赛—4

原题链接:5999. 统计数组中好三元组数目

给你两个下标从 0 开始且长度为 n 的整数数组 nums1 和 nums2 ，两者都是 [0, 1, …, n - 1] 的 排列 。

好三元组 指的是 3 个 互不相同 的值，且它们在数组 nums1 和 nums2 中出现顺序保持一致。换句话说，如果我们将 $pos{1}_v$ 记为值 v 在 nums1 中出现的位置，$pos{2}_v$ 为值 v 在 nums2 中的位置，那么一个好三元组定义为 0 <= x, y, z <= n - 1 ，且 $pos{1}_x<pos{1}_y<pos{1}_z$ 和 $pos{2}_x<pos{2}_y<pos{2}_z$ 都成立的 (x, y, z) 。

请你返回好三元组的 总数目 。

示例 1：

输入：nums1 = [2,0,1,3], nums2 = [0,1,2,3]
输出：1
解释：
总共有 4 个三元组 (x,y,z) 满足 pos1x < pos1y < pos1z ，分别是 (2,0,1) ，(2,0,3) ，(2,1,3) 和 (0,1,3) 。
这些三元组中，只有 (0,1,3) 满足 pos2x < pos2y < pos2z 。所以只有 1 个好三元组。

示例 2：

输入：nums1 = [4,0,1,3,2], nums2 = [4,1,0,2,3]
输出：4
解释：总共有 4 个好三元组 (4,0,3) ，(4,0,2) ，(4,1,3) 和 (4,1,2)

解析:
该题我们可以使用树状数组来解答,首先记录每个数在数组二中的位置，然后按照数组一的顺序依次处理。

我们考虑以当前数字作为三元组中间数字的好三元组的数目。第一个数字需要是之前已经遍历过的，并且在数组二中的位置比当前数字更靠前的；第三个数字需要是当前还没有遍历过的，并且在数组二中的位置比当前数字更靠后的。这里只对数字的位置有要求，而对数字具体的值没有要求。

如何快速求出满足条件的第一个数字和第三个数字的个数呢？

以 [4,1,0,2,3]为例，考虑我们的遍历过程：

首先处理的是 4，此时数组二中的出现情况为：

[4,X,X,X,X]

我们需要统计的是 4 之前的有值的个数（0 个），以及 4 之后的没有值的个数（4 个）。因此以 4 为中间数字能形成 0 个好三元组。

接下来是 0，此时数组二中的出现情况为：

[4,X,0,X,X]

0 之前有值的个数（1 个），0 之后没有值的个数（2 个）。因此以 0 为中间数字能形成 2 个好三元组。

接下来是 1，此时数组二中的出现情况为：

[4,1,0,X,X]

1 之前有值的个数（1 个），1 之后没有值的个数（2 个）。因此以 1 为中间数字能形成 2 个好三元组。

接下来是 3，此时数组二中的出现情况为：

[4,1,0,X,3]

3 之前有值的个数（3 个），3 之后没有值的个数（0 个）。因此以 3 为中间数字能形成 0 个好三元组。

最后是 2，此时数组二中的出现情况为：

[4,1,0,2,3]

2 之前有值的个数（3 个），2 之后没有值的个数（0 个）。因此以 2 为中间数字能形成 0 个好三元组。

最后的答案是 4。

因为我们并不关心数字具体的值，而只关心是否出现过，所以我们实际上可以把数组二的出现情况用一个 0–1 数组来表示：

[1,0,0,0,0]→[1,0,1,0,0]→[1,1,1,0,0]→[1,1,1,0,1]→[1,1,1,1,1]

这时可以看出，我们用树状数组（或者线段树、平衡树）就能快速更新状态，并求出我们需要的两个数值（左边的 1 的个数和右边的 0 的个数）。

class Solution {
    public long goodTriplets(int[] nums1, int[] nums2) {
        long ans = 0;
        int len = nums1.length;
        int[] index = new int[len];
        for (int i = 0; i < len; i++) {
            index[nums2[i]] = i;
        }
        BIT bit = new BIT(len + 1);
        //共计有len个数字,i个1
        //left个1出现在左边,i-left个1出现在右边
        //右边共有(len-index[nums1[i]]-1)个数字为0
        for (int i = 0; i < len; i++) {
            int left = bit.query(index[nums1[i]] + 1);
            int right = len - index[nums1[i]] - 1 - (i - left);
            ans += (long) right * left;
            bit.update(index[nums1[i]] + 1, 1);
        }
        return ans;
    }
}

/**
 * 树状数组
 */
class BIT {
    private int[] bit;

    public BIT(int n) {
        bit = new int[n];
    }

    /**
     * 前缀求和
     *
     * @param index 下标
     * @return 前缀和
     */
    public int query(int index) {
        int result = 0;
        for (; index >= 1; index -= Integer.lowestOneBit(index)) {
            result += bit[index];
        }
        return result;
    }

    /**
     * 数组下标加上对应的值
     *
     * @param index 下标
     * @param value 值
     */
    public void update(int index, int value) {
        for (; index < bit.length; index += Integer.lowestOneBit(index)) {
            bit[index] += value;
        }
    }
}