Doubt [贪心, 0/1 Trie树]

最新推荐文章于 2024-03-19 13:35:45 发布

Zbr162

最新推荐文章于 2024-03-19 13:35:45 发布

阅读量214

点赞数

分类专栏：基础算法-贪心 Second

本文链接：https://blog.csdn.net/Zbr162/article/details/100890961

版权

Second 同时被 2 个专栏收录

109 篇文章 0 订阅

订阅专栏

基础算法-贪心

9 篇文章 0 订阅

订阅专栏

$D o u b t$

$\color{grey}{最初想法}$

按顺序构造 $c_i$ , 每次贪心地将 $\min(a \bigoplus b)$ 取出, 作为 $c_i$ , 可以保证字典序最小,
朴素实现是 $O(N^2)$ 的, 加上用桶对第二个测试点相同的数字加速处理可以获得 $50 p t s$ .

考虑直接找每个 $a_i$ 所匹配的 $b_i$ , 发现若 $a_i$ 找了 $b_i$ , 会影响到后面的 $a_j$ 找 $b_i$ , 换句话说, 这样会有后效性 .

$\color{red}{正解部分}$

不用关心 $a_i$ 匹配哪个 $b_i$ , 只需使得 $c$ 的 较小值较小 即可实现字典序最小,

于是对 $a$ 和 $b$ 分别开一个深度越大, 位数越低的 $0/1\ Trie$ 树,
从两颗 $T r i e$ 树贪心地从根节点同步向下走, 优先走权值相同的节点, 使得 $c$ 的 越小值越小 即可 .

$\color{red}{实现部分}$

根节点的下标赋为 $1$ , $0$ 节点留作虚点, 用来判边界 .
$T r i e$ 中的 $A d d ()$ 函数, $t o$ 要开 $b o o l$ 类型 .

#include<bits/stdc++.h>
#define reg register

int read(){
        char c;
        int s = 0, flag = 1;
        while((c=getchar()) && !isdigit(c))
                if(c == '-'){ flag = -1, c = getchar(); break ; }
        while(isdigit(c)) s = s*10 + c-'0', c = getchar();
        return s * flag;
}

const int maxn = 6e6 + 10;

struct Trie{

        int rot;
        int node_cnt;

        struct Node{ int ch[2], cnt; } T[maxn];

        void Add(int x){
                int cur = rot;
                for(reg int i = 30; i >= 0; i --){
                        bool to = (x & (1 << i));
                        if(!T[cur].ch[to]) T[cur].ch[to] = ++ node_cnt;
                        cur = T[cur].ch[to];
                        T[cur].cnt ++;
                }
        }

} t_a, t_b;

int c_cnt;
int c[maxn];

void DFS(int k_1, int k_2, int sum, int pw){
        if(k_1) t_a.T[k_1].cnt --, t_b.T[k_2].cnt --;
        if(pw == 0){ c[++ c_cnt] = sum; return ; }
        while(t_a.T[t_a.T[k_1].ch[0]].cnt && t_b.T[t_b.T[k_2].ch[0]].cnt) DFS(t_a.T[k_1].ch[0], t_b.T[k_2].ch[0], sum, pw>>1);
        while(t_a.T[t_a.T[k_1].ch[1]].cnt && t_b.T[t_b.T[k_2].ch[1]].cnt) DFS(t_a.T[k_1].ch[1], t_b.T[k_2].ch[1], sum, pw>>1);
        while(t_a.T[t_a.T[k_1].ch[1]].cnt && t_b.T[t_b.T[k_2].ch[0]].cnt) DFS(t_a.T[k_1].ch[1], t_b.T[k_2].ch[0], sum|pw, pw>>1);
        while(t_a.T[t_a.T[k_1].ch[0]].cnt && t_b.T[t_b.T[k_2].ch[1]].cnt) DFS(t_a.T[k_1].ch[0], t_b.T[k_2].ch[1], sum|pw, pw>>1);
}

int N;

int main(){
        N = read();
        t_a.rot = t_b.rot = 1;
        t_a.node_cnt = t_b.node_cnt = 1;
        for(reg int i = 1; i <= N; i ++) t_a.Add(read());
        for(reg int i = 1; i <= N; i ++) t_b.Add(read());
        DFS(1, 1, 0, 1<<30);
        std::sort(c+1, c+c_cnt+1);
        for(reg int i = 1; i <= c_cnt; i ++) printf("%d ", c[i]);
        return 0;
}