leetcode1310. 子数组异或查询

最近一直没参加周赛，今天遇到这道题，感觉有点意思，可以试着写下心路历程
题目：
有一个正整数数组 arr，现给你一个对应的查询数组 queries，其中 queries[i] = [Li, Ri]。
对于每个查询 i，请你计算从 Li 到 Ri 的 XOR 值（即 arr[Li] xor arr[Li+1] xor … xor arr[Ri]）作为本次查询的结果。
并返回一个包含给定查询 queries 所有结果的数组。

示例 1：
输入：arr = [1,3,4,8], queries = [[0,1],[1,2],[0,3],[3,3]]
输出：[2,7,14,8]
解释：
数组中元素的二进制表示形式是：
1 = 0001
3 = 0011
4 = 0100
8 = 1000
查询的 XOR 值为：
[0,1] = 1 xor 3 = 2
[1,2] = 3 xor 4 = 7
[0,3] = 1 xor 3 xor 4 xor 8 = 14
[3,3] = 8
示例 2：

输入：arr = [4,8,2,10], queries = [[2,3],[1,3],[0,0],[0,3]]
输出：[8,0,4,4]

提示：
1 <= arr.length <= 3 * 10^4
1 <= arr[i] <= 10^9
1 <= queries.length <= 3 * 10^4
queries[i].length == 2
0 <= queries[i][0] <= queries[i][1] < arr.length

解答：
方法1：第一时间的想法，肯定不能一个个答案写啊，会超时啊，那我建立数组，使用动态规划，把所有的都列举出来，那最后的答案也就出来了，很可惜，内存不够，啪啪打脸，代码就不贴了。
方法2：暴力求解，哈哈，虽然要几百毫秒，咋说也是求出来了，代码在方法3中有使用，也就不重复粘贴了。
方法3：虽然暴力求出来了，但是还是心有不甘，想到之前的基数排序，我有个想法，我虽然不能直接得出答案，但是我可以把中间的大部分进行合并，这样也不用挨个计算了。
例如：queries[k] = [821,39384];
我们如果提前以100为界限进行，那就是计算821-899(79次)，900-39299(每100一次，284次)，39300-39384(85次)，共448次xor运算，原本是要进行38564次运算。
代码如下：

public int[] xorQueries(int[] arr, int[][] queries) {
    int[] ans = new int[queries.length];
    if (arr.length <= 1000) {
        //数组小，可用直接算
        for (int i = 0; i < queries.length; i++) {
            for (int j = queries[i][0]; j <= queries[i][1]; j++) {
                ans[i] ^= arr[j];
            }
        }
    } else {
        int step = (int) Math.sqrt(arr.length);
        int[] temp = new int[arr.length / step];
        //建立一些区域数组
        for (int i = 0; i < temp.length; i++) {
            for (int j = step * i; j < step * (i + 1); j++) {
                temp[i] ^= arr[j];
            }
        }
        for (int i = 0; i < queries.length; i++) {
            if (queries[i][1] - queries[i][0] < step) {
                //需要的计算量小
                for (int j = queries[i][0]; j <= queries[i][1]; j++) {
                    ans[i] ^= arr[j];
                }
                continue;
            }
            int l = (queries[i][0] + step - 1) / step;
            int r = queries[i][1] / step;
            //左边多出的部分
            for (int j = queries[i][0]; j < l * step; j++) {
                ans[i] ^= arr[j];
            }
            //右边多出的部分
            for (int j = r * step; j <= queries[i][1]; j++) {
                ans[i] ^= arr[j];
            }
            //把区域内的数值计算出来
            for (int j = l; j < r; j++) {
                ans[i] ^= temp[j];
            }
        }
    }
    return ans;
}

ps：现在还没想到更快的方法，唯一能有点进步的优化就是
判断修改：if (arr.length <= 100 || queries.length < 10)
阶梯修改：int step = (int) Math.sqrt(arr.length)/1.7;
时间最快是42ms。

方法4：前缀和

public int[] xorQueries(int[] arr, int[][] queries) {
    int[] ans = new int[queries.length];
    int[] temp = new int[arr.length + 1];
    //建立一些区域数组
    for (int i = 0; i < arr.length; i++) {
        temp[i + 1] = temp[i] ^ arr[i];
    }
    for (int i = 0; i < queries.length; i++) {
        ans[i] = temp[queries[i][1] + 1] ^ temp[queries[i][0]];
    }
    return ans;
}