C/C++ Group A Question H of the 14th Lanqiao Cup Provincial Competition - XOR and Sum (AC)

1. XOR and sum

1. Description of the topic

Given an array $A_i$, find the XOR sum of each of its sub-segments, and find their sum. In other words, for each group satisfying $1\le L\le R\le n$ L$L,R$ , find the$L$ toRRXOR sum of$R\; elements.$Then output each set of$L,$The sum of the results obtained by$R.$

2. Input format

The first line of input contains an integer $n$。

The second line contains $n$ integers$A_i$, separated by a space between adjacent integers.

3. Output format

Output a line containing an integer representing the answer.

4. Sample input

5
1 2 3 4 5

5. Sample output

39

6. Data range

For $30\%$ of the evaluation cases,$n\le 300$；

For $60\%$ of the evaluation cases,$n\le 5000$；

For all evaluation cases, $1\le n\le 10^5$，$0\le A_i\le 2^{20}$。

7. Link to the original title

XOR and sum

2. Problem-solving ideas

First, violently enumerate each subinterval $[l,r]$ $(1\le l\le r\le n)$ , the complexity will be$O\left(n^2\right)$, can't pass this question, but can get a certain score.

Since an XOR operation is involved and observing $a_i$The range of values ​​is $[0,2^{20}]$, it is not difficult for us to think about the problem from the perspective of "disassembly". Assume that for the i-th ∈ [ 0 , 20 ] i \in[0,20]of the binary bit$i\in [0,20]$ bits, there are$The\; XOR\; sum\; of\; the\; x$ sub-intervals at this bit is$1$ , then the contribution of this bit to the answer is$2^i\times x$ . In this way, we split the whole big problem into$20$ sub-questions, the original array is equivalent to being split into 20 20by us$20$ 01$01$ array.

For each subquestion, that is, for each $01$ array, we need to find out how many sub-arrays whose XOR sum is$1$ , that is to find the xxmentioned above$x$ . We can solve this problem by prefix XOR. Set here$01$ array is$a$ array, we set another$S$ pairs,$S_i$means $a$ array beforeiiWhat is the XOR sum of$i\; elements.$According to the nature of the XOR operation:

$$a_i\oplus a_{i+1}\oplus \cdots \oplus a_{j-1}\oplus a_j=(a_1\oplus a_2\oplus \cdots a_j)\oplus (a_1\oplus a_2\oplus \cdots \oplus a_{i-1})$$

Apply the above formula to $S$ is replaced with:

$$a_i\oplus a_{i+1}\oplus \cdots \oplus a_{j-1}\oplus a_j=S_{i-1}\oplus S_j$$

If you want to make the left side of the equation equal to $1$ , which means$S_{i-1}\ne S_j$。

According to the above analysis, we can enumerate each $01$ The prefix XOR array$S$ , when we enumerate to$S_j$, we only need to consider how many $S_i$Unlike it, the different numbers are equal to $a_j$end and XOR sum is 1 1The number of sub-arrays of$1\; ,\; we\; can\; use\; the\; hash\; table\; to\; realize\; the\; function\; of\; counting\; the\; number.$

This way we can run in close to $The\; complexity\; of\; O\left(n\right)$ counts each$01$ Array sub-interval XOR is$The\; number\; of\; 1$ , we set theii01 01$of\; i$ binary digits$01$ Array sub-interval XOR is$The\; number\; of\; 1$ is$b_i$, the final answer is:

$$\sum _{i=0}^{20}{2}^i\times b_i$$

Time complexity: $O(20\times n)$。

3. AC_Code

• C++

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 100010;

int n;
int a[N][25];
int main()
{
    
    
	ios_base :: sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n;
	for (int i = 1; i <= n; ++i) {
    
    
		int x;
		cin >> x;
		for (int j = 0; j <= 20; ++j) {
    
    
			a[i][j] = (x >> j) & 1;
			a[i][j] ^= a[i - 1][j];
		}
	}
	LL ans = 0;
	for (int j = 0; j <= 20; ++j) {
    
    
		map<int, int> m;
		m[0]++;
		for (int i = 1; i <= n; ++i) {
    
    
			int x = m[a[i][j] ^ 1];
			ans += 1LL * (1 << j) * x;
			m[a[i][j]]++;
		}
	}
	cout << ans << '\n';
	return 0;
}

• Java

import java.util.*;

public class Main {
    
    
    static final int N = 100010;

    public static void main(String[] args) {
    
    
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[][] a = new int[N][25];
        for (int i = 1; i <= n; ++i) {
    
    
            int x = scan.nextInt();
            for (int j = 0; j <= 20; ++j) {
    
    
                a[i][j] = (x >> j) & 1;
                a[i][j] ^= a[i - 1][j];
            }
        }
        long ans = 0;
        for (int j = 0; j <= 20; ++j) {
    
    
            Map<Integer, Integer> m = new HashMap<>();
            m.put(0, 1);
            for (int i = 1; i <= n; ++i) {
    
    
                int x = m.getOrDefault(a[i][j] ^ 1, 0);
                ans += (1L << j) * x;
                m.put(a[i][j], m.getOrDefault(a[i][j], 0) + 1);
            }
        }
        System.out.println(ans);
    }
}

• Python

n = int(input())
N = 100010
a = [[0] * 25 for _ in range(N)]
b = list(map(int, input().split()))
for i in range(1, n + 1):
    x = b[i-1]
    for j in range(21, -1, -1):
        a[i][j] = (x >> j) & 1
        a[i][j] ^= a[i - 1][j]
ans = 0
for j in range(21, -1, -1):
    m = {
    
    0: 1}
    for i in range(1, n + 1):
        x = m.get(a[i][j] ^ 1, 0)
        ans += (1 << j) * x
        m[a[i][j]] = m.get(a[i][j], 0) + 1
print(ans)