【LeetCode】前缀和篇

传送门	难度
1442. 形成两个异或相等数组的三元组数目	中等

撸码时间

1、1442. 形成两个异或相等数组的三元组数目

题目描述：
给你一个整数数组 arr 。
现需要从数组中取三个下标 i、j 和 k ，其中 (0 <= i < j <= k < arr.length) 。
a 和 b 定义如下：
a = arr[i] ^ arr[i + 1] ^ … ^ arr[j - 1]
b = arr[j] ^ arr[j + 1] ^ … ^ arr[k]
注意：^ 表示 按位异或 操作。
请返回能够令 a == b 成立的三元组 (i, j , k) 的数目。

示例：

输入：arr = [2,3,1,6,7]
输出：4
解释：满足题意的三元组分别是 (0,1,2), (0,2,2), (2,3,4) 以及 (2,4,4)

解法：前缀和
思路：
首先我们先回顾一下异或运算符。
在java中，异或运算符为^，其运算规则如下。

0 ^ 0	0 ^ 1	1 ^ 0	1 ^ 1
0	1	1	0

即相同为0，不同为1。
a ^ b ^ a = b
利用这个公式，很容易想到利用前缀和来解决。
第一步就是定义一个数组，将前n项的异或保存。
后面就是计算a和b的值，然后判断相等count就+1

public int countTriplets(int[] arr) {
        int count = 0;
        long[] newArr = new long[arr.length + 1];
        // 前n项的异或
        for (int i = 1; i < newArr.length; i++) {
            newArr[i] = newArr[i - 1] ^ arr[i - 1];
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                long a = newArr[j] ^ newArr[i];
                for (int k = j; k < arr.length; k++) {
                    long b = newArr[k+1] ^ newArr[j];
                    if (a == b) {
                        count++;
                    }
                }
            }
        }
        return count;
    }

这里需要注意的是利用前缀和计算a和b的值时index的问题，
首先a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1]，a是从数组的第i+1
项异或到第j项，那么前j项的异或为newArr[j]，需要消除前i项的异或，所以a = newArr[j] ^ newArr[i]，b同理。
然后我们按照需求写出了3重循环的代码，这里可以进行一个小小的优化，a=b => newArr[j] ^ newArr[i] = newArr[j] ^ newArr[k+1] => newArr[i] = newArr[k+1]，这样就少计算a和b的值，可以直接比较。

class Solution {
    public int countTriplets(int[] arr) {
        int count = 0;
        long[] newArr = new long[arr.length + 1];
        for (int i = 1; i < newArr.length; i++) {
            newArr[i] = newArr[i - 1] ^ arr[i - 1];
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                for (int k = j; k < arr.length; k++) {
                    if (newArr[i] == newArr[k+1]) {
                        count++;
                    }
                }
            }
        }
        return count;
    }
}

看一下执行时间：

可以看到提升了10ms的时间。
那么还能不能再进一步优化呢？毕竟现在依旧是三重循环。
我们可以发现，当我们进行了上一步的优化之后，第二重j循环似乎没有了意义，当我们满足newArr[i] = newArr[k+1]时，所有符合条件的j都可以，所以每次计算符合条件的j的数量就可以。
由条件知道i<j<=k，所以每次count = k-(i+1)+1 = k-i

class Solution {
    public int countTriplets(int[] arr) {
        int count = 0;
        long[] newArr = new long[arr.length + 1];
        for (int i = 1; i < newArr.length; i++) {
            newArr[i] = newArr[i - 1] ^ arr[i - 1];
        }

        for (int i = 0; i < arr.length; i++) {
            // for (int j = i + 1; j < arr.length; j++) {
                for (int k = i+1; k < arr.length; k++) {
                    if (newArr[i] == newArr[k+1]) {
                        count += k-i;
                    }
                }
            // }
        }
        return count;
    }
}

现在变成了2重循环，这是一个量级的提升！
看一下执行时间

效果很明显～

官方后面优化成一个循环搞定，贴上官方代码

class Solution {
    public int countTriplets(int[] arr) {
        int n = arr.length;
        int[] s = new int[n + 1];
        for (int i = 0; i < n; ++i) {
            s[i + 1] = s[i] ^ arr[i];
        }
        Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();
        Map<Integer, Integer> total = new HashMap<Integer, Integer>();
        int ans = 0;
        for (int k = 0; k < n; ++k) {
            if (cnt.containsKey(s[k + 1])) {
                ans += cnt.get(s[k + 1]) * k - total.get(s[k + 1]);
            }
            cnt.put(s[k], cnt.getOrDefault(s[k], 0) + 1);
            total.put(s[k], total.getOrDefault(s[k], 0) + k);
        }
        return ans;
    }
}