2021-08-07：与数组中元素的最大异或值。给你一个由非负整数组成的数组 nums 。另有一个查询数组 queries ，其

package main

import (
    "fmt"
    "math"
)

func main() {
    nums := []int{0, 1, 2, 3, 4}
    queries := [][]int{{3, 1}, {1, 3}, {5, 6}}
    ret := maximizeXor(nums, queries)
    fmt.Println(ret)
}

func maximizeXor(nums []int, queries [][]int) []int {
    N := len(nums)
    trie := NewNumTrie()
    for i := 0; i < N; i++ {
        trie.add(nums[i])
    }
    M := len(queries)
    ans := make([]int, M)
    for i := 0; i < M; i++ {
        ans[i] = trie.maxXorWithXBehindM(queries[i][0], queries[i][1])
    }
    return ans
}

type Node struct {
    min   int
    nexts []*Node
}

func NewNode() *Node {
    ans := &Node{}
    ans.min = math.MaxInt64
    ans.nexts = make([]*Node, 2)
    return ans
}

func getMin(a int, b int) int {
    if a < b {
        return a
    } else {
        return b
    }
}

type NumTrie struct {
    head *Node
}

func NewNumTrie() *NumTrie {
    ans := &NumTrie{}
    ans.head = NewNode()
    return ans
}

func (this *NumTrie) add(num int) {
    cur := this.head
    this.head.min = getMin(this.head.min, num)
    for move := 30; move >= 0; move-- {
        path := (num >> move) & 1
        if cur.nexts[path] == nil {
            cur.nexts[path] = NewNode()
        } else {
            cur.nexts[path] = cur.nexts[path]
        }
        //cur.nexts[path] = cur.nexts[path] == null ? new Node() : cur.nexts[path];
        cur = cur.nexts[path]
        cur.min = getMin(cur.min, num)
    }
}

// 这个结构中，已经收集了一票数字
// 请返回哪个数字与X异或的结果最大，返回最大结果
// 但是，只有<=m的数字，可以被考虑
func (this *NumTrie) maxXorWithXBehindM(x int, m int) int {
    if this.head.min > m {
        return -1
    }
    // 一定存在某个数可以和x结合
    cur := this.head
    ans := 0
    for move := 30; move >= 0; move-- {
        path := (x >> move) & 1
        // 期待遇到的东西
        best := path ^ 1
        if cur.nexts[best] == nil || cur.nexts[best].min > m {
            best ^= 1
        } else {
            best ^= 0
        }
        //best ^= (cur.nexts[best] == null || cur.nexts[best].min > m) ? 1 : 0;
        // best变成了实际遇到的
        ans |= (path ^ best) << move
        cur = cur.nexts[best]
    }
    return ans
}