字节真题 ZJ26-异或：使用字典树代替暴力破解降低时间复杂度

import java.util.Scanner;

public class Xor {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        TrieTree tree = new TrieTree();

        while(sc.hasNext()){
            int n = sc.nextInt();
            int m = sc.nextInt();
            long total = 0;
　　　　　　　 //插入A1
            tree.insert(sc.nextInt());
            for(int i = 0; i < n - 1; i ++){
                int me = sc.nextInt();
             　 //找出和Ax异或后结果大于m的数有多少个，并且累加
　　　　　　　    total += tree.compare(me, m);
　　　　　　　　  //插入Ax
                tree.insert(me);
            }
　　　　　　　//输出结果
            System.out.println(total);
        }
    }
    private static class Node{
　　　　 //有多少个数有当前前缀
        public int count = 1;
　　　　 //子节点
        public Node[] child = new Node[2];
    }

    private static class TrieTree{
　　　　 //根节点
        Node root;
　　　　 
        public TrieTree(){
            //根节点不包含信息，卫星数据
　　　　　　  this.root = new Node();
        }

        public int compare(int tar, int m){
        }

        public void insert(int tar){
        }
    }
}

        public void insert(int tar){
            Node now = root;
            root.count ++;
            //从第二位开始，忽略最高为第一位，所有输入都是正数，忽略最高符号位
            for(int i = 30; i >= 0; i --){
                //获取要插入的数的第(32 - i )位
                int res = (tar >>> i) & 1;
                //如果之前不存在节点，则新建节点，count 默认 = 1
                if(now.child[res] == null){
                    now.child[res] = new Node();
                    now = now.child[res];
                }else{
                //如果之前已经有节点存在，则count++
                    now = now.child[res];
                    now.count ++;
                }
            }
        }            

 　　　　 // now : 当前前缀树中，需要开始比较的节点
        // tar : 将要插入的数，但是在调用insert插入之前，要和已经插入的数比较（当前前缀树）
        // m : 要大于的那个树
        // bit : 当前节点的儿子们表示的是对第几位的比较
        public int compare(Node now, int Ax, int m, int bit){
            //逐位比较
            for(int i = bit; i >= 0; i --){
                if(now == null){
                    //空节点 表示两者相同 情况5
                    return 0;
                }
                int res = (Ax >>> i) & 1;
                //存在能够 XOR 出 1 的路径, 情况1或2
                if((now.child[res ^ 1]) != null){
                    //如果目标的当前位是 0，说明异或结果已经小于 Ax
                    if(((m >>> i) & 1) == 0){
                        //情况1
　　　　　　　　　　　　　　 //但是不能单纯只返回异或结果大于m的那条路径上的分支数量
                        //因为当前位异或结果相等于m的那条路径上的分支可能还存在满足异或结果大于m的情况
                        return now.child[res ^ 1].count + compare(now.child[res], tar, m, i - 1);
                    } else {
　　　                  //情况2
　　　　　　　　　　　　　　//异或结果相等 接着找
                        now = now.child[res ^ 1];
                    }
                } else{
                    //情况3
                    //异或结果小于 m， 直接返回0
                    if(((m >>> i) & 1) == 1){
                        return 0;
                    }
                    //情况4
　　　　　　　　　　　　//异或结果相等，接着找
                    now = now.child[res];
                }
            }
　　　　　　　//默认返回0
            return 0;
        }