Codeforces Round 943 (Div. 3) F. Equal XOR Segments

、

按位异或：

        

按位异或（Bitwise XOR）是一种位运算，它对二进制位执行异或（XOR）操作。
XOR操作的规则是：当两个对应的二进制位相异时，结果为1；当两个对应的二进制位相同时，结果为0。
在大多数编程语言中，按位异或运算符是^。
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0

eg：
A: 10101010  
B: 01010101  
  
A ^ B:  
   10101010  
^  01010101  
=  11111111

任何数与0进行异或运算，结果仍然是原来的数，即 a ^ 0 = a。
任何数与自身进行异或运算，结果是0，即 a ^ a = 0。
异或运算满足交换律和结合律：a ^ b = b ^ a 和 (a ^ b) ^ c = a ^ (b ^ c)。
异或前缀和：：b1=a1
 和 bi=bi−1⊕ai
 现在， al⊕al+1⊕⋯⊕ar=br⊕bl−1

#include<bits/stdc++.h>

using namespace std;

typedef long long LL;

const int N = 2e5 + 10;

int a[N],s[N];

void slove()
{
    int n,q;
    cin >>n >> q;
    
    map<int , vector<int>> mp;
    
    mp[0].push_back(0);
    for(int i = 1;i<=n;i++)
    {
        cin >>a[i];
        s[i] = s[i - 1] ^ a[i];
        mp[s[i]].push_back(i);
    }
    
    while(q --)
    {
        int l,r;
        cin >>l>>r;
        if(s[l - 1] == s[r]) puts("YES");
        else 
        {
            auto &v1 = mp[s[r]] , &v2 = mp[s[l - 1]];
            auto it1 = lower_bound(v1.begin(),v1.end(),l);
             auto it2 = lower_bound(v2.begin(),v2.end(),r);
    /*mp[s[r]]中存储的是所有异或和为s[r]的所有的下表，因为要找到第一个大于等于l的值
lower_bound 函数在这里被用来在 mp[s[r]] 中找到第一个不小于 l 的位置。这是因为如果 mp[s[r]] 中存在这样的位置 j（即 j >= l），那么从位置 j 到 r 的子数组和从位置 l 到某个位置（在 mp[s[l-1]] 中）的子数组可能有相同的异或和，所以在s[r]中找到符合条件的下表
      mp[s[l - 1]] 中存储的是所有异或和为s[l- 1]的所有的下表，
             
             if(it1 != v1.end() && it2 != v2.begin() && *it1 < *prev(it2))
//，*prev(it2)用于获取it2前一个迭代器所指向的元素（即大于r的最小位置的前一个位置），以确保两个
//子数组不相交。
*/
                puts("YES");
                else puts("NO");
            
        }
    }
    
}

int main()
{
    int t;
    cin >> t;
    
    while(t --)
    {
        slove();
        puts("");
    }
    
    return 0;
}

使用两个 map（或 unordered_map）来存储异或前缀和到它们出现位置的映射。然后，您可以利用这些映射来查找是否存在两个不相交的子数组，它们的异或和分别是 s[r] 和 s[l-1]。这是通过检查 mp[s[r]] 中是否存在大于或等于 l 的位置，以及 mp[s[l-1]] 中是否存在大于 r 的位置（确保两个子数组不相交）来实现的。