Kanade's trio

HDU 6059



求有多少对（i < j < k），满足a[i] xor a[j] < a[j] xor a[k]。
一开始想着就是枚举j，维护两颗字典树G、F，分别记录[1,j-1] , [j+1,n]的数（二进制）以及出现的次数。对于每一次查找一开始没想好，先试试直接深搜，即每次找前面都相同的，当前值会使得产生a[i] xor a[j] < a[j] xor a[k]形式的进行相乘算入答案中，但是这样肯定超时，因为对于每一个节点都会对0、1两边进行深搜，即使加了优化也不行。那么看回上面的思路，只有当前面的都相同，当前位出现差异的才有可能算入答案，那么在维护字典树的同时维护一个num[i][0/1]数组，num[i][0]表示在当前枚举的j维护完之后，在字典树G和F中，前i-1位相同，第i位G中为0，F中为1的个数。同理num[i][1]就是相反，G为1，F为0的个数。维护好num，只需要对a[j]的二进制形式进行扫描，如果第i位为1，那么贡献就是num[i][1]，否则为num[i][0]。

当时赶时间代码写得比较丑…

#include <bits/stdc++.h>
#include <vector>
using namespace std;

const int maxn = 500050;
struct Node {
    int t;
    int p0, p1;
    Node() {t = p0 = p1 = 0;}
    Node(int tt): t(tt) {p0 = p1 = 0;}
};
vector<Node> G, F;
long long ans, num[35][2];
int b[35], n, a[maxn];


void add(vector<Node> &a, int t) {
    int temp[35] = {0};
    for (int i = 1; i <= 30; i++) {
        temp[i] = t%2;
        t /= 2;
    }
    int x = 0;
    a[x].t++;
    for (int i = 30; i >= 1; i--) {
        if (temp[i]) {
            if (a[x].p1 == 0) {
                a.push_back(Node(1));
                a[x].p1 = a.size()-1;
                x = a[x].p1;
            } else {
                x = a[x].p1;
                a[x].t++;
            }
        } else {
            if (a[x].p0 == 0) {
                a.push_back(Node(1));
                a[x].p0 = a.size()-1;
                x = a[x].p0;
            } else {
                x = a[x].p0;
                a[x].t++;
            }
        }
    }
}

void insert(int t) {
    int temp[35] = {0};
    for (int i = 1; i <= 30; i++) {
        temp[i] = t%2;
        t /= 2;
    }
    int x = 0, y = 0;
    G[x].t++;
    for (int i = 30; i >= 1; i--) {
        if (temp[i]) {// 11111111111111111111111111
            if (G[x].p1 == 0) {
                G.push_back(Node(1));
                G[x].p1 = G.size()-1;
                if (y != -1 && F[y].p0) {
                    num[i][1] += F[F[y].p0].t;
                }
                x = G[x].p1;
                if (y != -1 && F[y].p1) y = F[y].p1;
                else y = -1;
            } else {
                G[G[x].p1].t++;
                if (y != -1 && F[y].p0) {
                    num[i][1] += F[F[y].p0].t;
                }
                x = G[x].p1;
                if (y != -1 && F[y].p1) y = F[y].p1;
                else y = -1;
            }
        } else {//000000000000000000
            if (G[x].p0 == 0) {
                G.push_back(Node(1));
                G[x].p0 = G.size()-1;
                if (y != -1 && F[y].p1) {
                    num[i][0] += F[F[y].p1].t;
                }
                x = G[x].p0;
                if (y != -1 && F[y].p0) y = F[y].p0;
                else y = -1;
            } else {
                G[G[x].p0].t++;
                if (y != -1 && F[y].p1) {
                    num[i][0] += F[F[y].p1].t;
                }
                x = G[x].p0;
                if (y != -1 && F[y].p0) y = F[y].p0;
                else y = -1;
            }
        }
    }
}

void cancel(int t) {
    int temp[35] = {0};
    for (int i = 1; i <= 30; i++) {
        temp[i] = t%2;
        t /= 2;
    }
    int x = 0, y = 0;
    F[y].t--;
    for (int i = 30; i >= 1; i--) {
        if (temp[i]) {///1111111111111
            if (x != -1 && G[x].p0) {
                num[i][0] -= G[G[x].p0].t;
            }
            y = F[y].p1;
            F[y].t--;
            if (x != -1 && G[x].p1) x = G[x].p1;
            else x = -1;
        } else {///00000000000000000
            if (x != -1 && G[x].p1) {
                num[i][1] -= G[G[x].p1].t;
            }
            y = F[y].p0;
            F[y].t--;
            if (x != -1 && G[x].p0) x = G[x].p0;
            else x = -1;
        }
    }
}

void init() {
    G.clear(); F.clear();
    G.push_back(Node(0));
    F.push_back(Node(0));
    memset(num, 0, sizeof(num));
    ans = 0;
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        if (i >= 2) add(F, a[i]);
    }
}

void dfs(int x, int y, int z) {
    if (z <= 0) return;
    if (G[x].t == 0 || F[y].t == 0) return;
    if (b[z]) {
        if (G[x].p1 && F[y].p0) ans += 1LL*G[G[x].p1].t*F[F[y].p0].t;
    } else {
        if (G[x].p0 && F[y].p1) ans += 1LL*G[G[x].p0].t*F[F[y].p1].t;
    }
    if (G[x].p0 && F[y].p0) dfs(G[x].p0, F[y].p0, z-1);
    if (G[x].p1 && F[y].p1) dfs(G[x].p1, F[y].p1, z-1);
}

void work() {
    for (int i = 2; i < n; i++) {
        insert(a[i-1]);
        cancel(a[i]);
        int t = a[i];
        memset(b, 0, sizeof(b));
        for (int i = 1; i <= 30; i++) {
            b[i] = t%2;
            t /= 2;
        }
        //dfs(0, 0, 30);
        for (int i = 1; i <= 30; i++) {
            if (b[i]) {
                ans += num[i][1];
            } else {
                ans += num[i][0];
            }
        }
        //printf("%d ", ans);
    }
    printf("%lld\n", ans);
}

int main() {
    int T;
    scanf("%d", &T);
    while (T--) {
        init();
        work();
    }
}