CodeForces - 1416C（字典树+贪心）

题意：给出数组a，让求一个数x，使得b数组（bi = ai ^ x）的逆序对最少，最小化逆序对数与x
思路：分层考虑，我们将这n个数的每一位放到字典树里，对于字典树的每一层的每个节点，算出他两个儿子逆序对的数量，如果正序大于逆序，那么x的这一位为0，否则为1，这样是最优的，这题细节很重要，代码里注释的都是wa的点

#include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define douinf 0x3f3f3f3f
#define IO ios::sync_with_stdio(false)
#define bug cout << "-----\n"
#define eps 1e-8
typedef long long  ll;
const int N = 300010;
int a[N],tire[N * 32][2];//每个ai都有31位，每位都可能让cnt++
ll num[32][2];
int cnt;
vector<int> vt[N * 32];//同样的，每个ai都有31位，cnt可能大于N
void build(int x,int pos) {
    int p = 0;
    for(int i = 30 ; i >= 0 ; i --){
        int t = (x >> i) & 1;
        if(tire[p][t] == 0)tire[p][t] = ++ cnt;
        p = tire[p][t];
        vt[p].push_back(pos);
    }
}
void dfs(int x,int pos) {
    if(pos == 31)return ;//一共30层，所以到31层返回，而不是30
    int l = tire[x][0],r = tire[x][1];
    ll res = 0,ans = 0;
    int This = 0,j = 0;
    for(int i = 0 ; i < vt[l].size() ; i ++) {//这个可以O(n),由于vt里的元素都是有序的，所以不用O(n^2)
        if(vt[r].size() == 0)break;
        for(; j < vt[r].size() ; j ++ ) {
            if(vt[l][i] > vt[r][j])ans ++;
            else break;
        }
        res += ans;
    }
    num[pos][0] += (ll)vt[l].size() * (ll)vt[r].size() - res;//这里一定要强转，乘积可能爆int
    num[pos][1]  += res;
    if(vt[l].size())dfs(l , pos + 1);
    if(vt[r].size())dfs(r , pos + 1);
}
int main() {
    IO;
    int n;cin >> n;
    for(int i = 0 ; i < n ; i ++){
        cin >> a[i];
        build(a[i] , i);
    }
    dfs(0 , 0);
    ll res = 0;
    int ans = 0;
    for(int i = 0 ; i <= 30 ; i ++) {
        if(num[i][0] < num[i][1]) {
            res += num[i][0];
            ans += (1 << (30 - i));
        }
        else if(num[i][0] >= num[i][1]) {//这里是大于等于，比如某一层正序和逆序相同，那么怎么换都得加上
            res += num[i][1];
        }
    }
    cout << res << ' ' << ans;
    return 0;
}