Codeforces 888G Xor-MST - 分治 - 贪心 - Trie

题目传送门

　　这是一条通往vjudge的高速公路

　　这是一条通往Codeforces的高速公路

题目大意

　　给定一个$n$阶完全图，每个点有一个权值$a_{i}$，边$(i, j)$的权值是$(a_{i}\  xor\  a_{j})$。一个生成树的权值是各边的权值和。问最小生成树的权值。　　

　　设值域为$[0, 2^{k})$。

　　当$k = 1$的时候，显然将点权为0的点之间互相连边，点权为1的点之间互相连边，中间随便连一条。

　　当$k = x\ (x > 1)$的时候，将这些点按照二进制的第$k$位分成两个集合。因为这两集合中间的点互相连边，边权的第$k$位会被消掉，于是变成了$k = x - 1$的子问题。

　　假如得到了它们的最优解，那么我只需要在两个连通块之间添加一条边权最小的边就行了。

　　考虑怎么找这样一条边。

　　我可以把其中一个集合中数插入Trie树，然后拿另一集合中的点的点权在Trie树中查最小异或和。

Code

 /**
  * Codeforces
  * Problem#888G
  * Accepted
  * Time: 327ms
  * Memory: 49772k
  */
 #include <bits/stdc++.h>
 #ifndef WIN32
 #define Auto "%lld"
 #else
 #define Auto "%I64d"
 #endif
 using namespace std;
 typedef bool boolean;

 #define ll long long

 typedef class TrieNode {
     public:
         TrieNode* ch[];

         TrieNode():ch({NULL, NULL}) {    }
 }TireNode;

 TrieNode pool[];
 TrieNode* top = pool;

 TrieNode* newnode() {
     top->ch[] = top->ch[] = NULL;
     return top++;
 }

 typedef class Trie {
     public:
         TrieNode* rt;

         Trie() {
             top = pool;
             rt = newnode();
         }

         void insert(int x, int dep) {
             int temp =  << dep, d;
             TrieNode *p = rt;
             while (temp) {
                 d = (temp & x) ? () : ();
                 if (!p->ch[d])
                     p->ch[d] = newnode();
                 p = p->ch[d], temp = temp >> ;
             }
         }

         int query(int x, int dep) {
             int temp =  << dep, rt = , d;
             TrieNode *p = this->rt;
             while (temp) {
                 d = (temp & x) ? () : ();
                 if (p->ch[d])
                     p = p->ch[d];
                 else
                     p = p->ch[d ^ ], rt |= temp;
                 temp = temp >> ;
             }
             return rt;
         }
 }Trie;

 int n;
 int *ar;
 Trie t;

 inline void init() {
     scanf("%d", &n);
     ar = new int[(n + )];
     for (int i = ; i <= n; i++)
         scanf("%d", ar + i);
 }

 ll dividing(int dep, int l, int r) {
     if (!dep)    return ar[l] ^ ar[r];
     int tl = l, tr = r, mid, temp =  << dep, mincost =  << ;
     while (tl <= tr) {
         mid = (tl + tr) >> ;
         if (ar[mid] & temp)
             tr = mid - ;
         else
             tl = mid + ;
     }
     if (tr == l -  || tr == r)
         return dividing(dep - , l, r);
     t = Trie();
     for (int i = l; i <= tr; i++)
         t.insert(ar[i], dep);
     for (int i = tr + ; i <= r; i++)
         mincost = min(mincost, t.query(ar[i], dep));
     return mincost + dividing(dep - , l, tr) + dividing(dep - , tr + , r);
 }

 inline void solve() {
     sort(ar + , ar + n + );
     printf(Auto"\n", dividing(, , n));
 }

 int main() {
     init();
     solve();
     return ;
 }