CF #365 703D. Mishka and Interesting sum
题目描述
D. Mishka and Interesting sum的意思就是给出一个数组，以及若干询问，每次询问某个区间[L, R]之间所有出现过偶数次的数字的异或和。
这个东西乍看很像是经典问题，一列数字中所有数字出现偶数次，除了一个数字只出现一次，找出那个只出现过一次的数字。然而这个问题并不是要找出现奇数次数字的异或和。
算法
有一个直观的思路是求出[L, R的异或和，再异或上[L, R]之间所有出现过的数字的异或和。这样的话就可以使得数字出现次数的奇偶性发生变化。
那么怎么求出区间[L, R]所有出现过的数字的异或和呢？
先想一下如果是求区间[L, R]有多少种不同的数字怎么做？这个可以在遍历的时候保存每个数字最后出现的位置，打标记（去掉上一次的标记，更新到当前位置），去数[L, R]有多少个标记就行了。
所以求[L, R]不同数字的异或和也是类似的做法，去掉之前出现位置的标记，给当前位置打上标记，去计算[L,R]所有标记异或和。
回到原问题，有了区间不同数字的异或和，再异或上区间本身的异或值，就可以实现奇偶性翻转来得出出现偶数次的数字的异或和。
具体的流程：
需要一个异或BIT/FenwickTree，以及一个hashmap来保存元素出现位置。
按照所有询问的right值排序，遍历所有数字，每一次遍历到当前要处理的询问的R值为止。
每一步都要先往BIT中i位置加一个a[i]（要做区间本身数字的异或）。
如果当前数字是第一次出现，则向BIT中i位置加一个a[i]，hashmap中标记a[i]出现的位置为i。
如果当前数字之前已经出现过了，先去除上一次的标记，即向BIT中last[a[i]]加一个a[i]（对于异或来说就抵消了），再向当前位置i加入一个a[i]，更新hashmap中a[i]的位置为i。
可以发现，无论数字是否是第一次出现，最终hashmap中都得要给i这个位置加一个a[i]，和上述每一个位置都要插入a[i]正好就抵消效果了。
所以流程可以简化为：每一步判断hashmap中是否存在a[i]，存在的话取出位置值，BIT中往这个位置加a[i]。 在hashmap中插入<a[i], i>。
每一个询问的答案就是bit.query(R)^bit.query(L-1)
实现
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskD solver = new TaskD();
solver.solve(1, in, out);
out.close();
}
static class TaskD {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.nextInt();
long[] a = new long[n + 1];
for (int i = 1; i <= n; i++) {
a[i] = in.nextLong();
}
int m = in.nextInt();
Query[] queries = new Query[m];
for (int i = 0; i < m; i++) {
queries[i] = new Query(i, in.nextInt(), in.nextInt());
}
Arrays.sort(queries, (o1, o2) -> Integer.compare(o1.right, o2.right));
Map<Long, Integer> pos = new HashMap<>();
FenwickTree tree = new FenwickTree(n) {
@Override
protected long operate(long data, long value) {
return data ^ value;
}
@Override
public long sum(int s, int t) {
return sum(t) ^ sum(s - 1);
}
};
int i = 1;
long[] result = new long[m];
for (Query query : queries) {
for (; i <= query.right; i++) {
if (pos.containsKey(a[i])) {
tree.add(pos.get(a[i]), a[i]);
}
pos.put(a[i], i);
}
result[query.id] = tree.sum(query.left, query.right);
}
for (long ret : result) {
out.println(ret);
}
}
class Query {
int id;
int left;
int right;
public Query(int id, int left, int right) {
this.id = id;
this.left = left;
this.right = right;
}
}
}
static class InputReader {
private final BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
static class FenwickTree {
private final long[] data;
public FenwickTree(int size) {
data = new long[size + 1];
}
public FenwickTree(long[] data) {
this.data = data;
}
private int lowBit(int x) {
return x & -x;
}
protected long operate(long data, long value) {
return data + value;
}
public final void add(int p, long v) {
for (int i = p; i < data.length; i += lowBit(i)) {
data[i] = operate(data[i], v);
}
}
public final long sum(int p) {
long ret = 0;
for (int i = p; i > 0; i -= lowBit(i)) {
ret = operate(ret, data[i]);
}
return ret;
}
public long sum(int s, int t) {
return sum(t) - sum(s - 1);
}
}
}
