【字典树（前缀树） 异或 离线查询】1707. 与数组中元素的最大异或值|2358

已于 2024-09-21 16:32:27 修改
阅读量823 收藏 32
点赞数 11
文章标签： 数据结构 leetcode c++ 字典树 前缀树 异或 离线查询
于 2024-05-26 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/138942439
版权

本文涉及知识点

离线查询
C++前缀树(字典树)
位运算、状态压缩、枚举子集汇总

LeetCode1707. 与数组中元素的最大异或值

给你一个由非负整数组成的数组 nums 。另有一个查询数组 queries ，其中 queries[i] = [xi, mi] 。
第 i 个查询的答案是 xi 和任何 nums 数组中不超过 mi 的元素按位异或（XOR）得到的最大值。换句话说，答案是 max(nums[j] XOR xi) ，其中所有 j 均满足 nums[j] <= mi 。如果 nums 中的所有元素都大于 mi，最终答案就是 -1 。
返回一个整数数组 answer 作为查询的答案，其中 answer.length == queries.length 且 answer[i] 是第 i 个查询的答案。
示例 1：
输入：nums = [0,1,2,3,4], queries = [[3,1],[1,3],[5,6]]
输出：[3,3,7]
解释：

  1. 0 和 1 是仅有的两个不超过 1 的整数。0 XOR 3 = 3 而 1 XOR 3 = 2 。二者中的更大值是 3 。
  2. 1 XOR 2 = 3.
  3. 5 XOR 2 = 7.
    示例 2：
    输入：nums = [5,2,4,6,6,3], queries = [[12,4],[8,1],[6,3]]
    输出：[15,-1,5]
    提示：
    1 <= nums.length, queries.length <= 105
    queries[i].length == 2
    0 <= nums[j], xi, mi <= 109

离线查询、字典树

indexs 记录 queries的下标。queries[index[i]][1] 升序。
for( i: indexs){
将小于等于mi的nums元素加到字典树。
y = 查询字典树和xi的最大异或值。
vRet[i] = y;
}

离线查询、字典树代码

核心代码

class C2BNumTrieNode
{
public:
	C2BNumTrieNode()
	{
		m_childs[0] = m_childs[1] = nullptr;
	}
	bool GetNot0Child(bool bFirstRight)
	{
		auto ptr = m_childs[bFirstRight];
		if (ptr && (ptr->m_iNum > 0))
		{
			return bFirstRight;
		}
		return !bFirstRight;
	}
	int m_iNum = 0;
	C2BNumTrieNode* m_childs[2];
};

template<class T = int, int iLeveCount = 31>
class C2BNumTrie
{
public:
	C2BNumTrie()
	{
		m_pRoot = new C2BNumTrieNode();
	}
	void  Add(T iNum)
	{
		m_setHas.emplace(iNum);
		C2BNumTrieNode* p = m_pRoot;
		for (int i = iLeveCount - 1; i >= 0; i--)
		{
			p->m_iNum++;
			bool bRight = iNum & ((T)1 << i);
			if (nullptr == p->m_childs[bRight])
			{
				p->m_childs[bRight] = new C2BNumTrieNode();
			}
			p = p->m_childs[bRight];
		}
		p->m_iNum++;
	}
	void Del(T iNum)
	{
		auto it = m_setHas.find(iNum);
		if (m_setHas.end() == it)
		{
			return;
		}
		m_setHas.erase(it);
		C2BNumTrieNode* p = m_pRoot;
		for (int i = iLeveCount - 1; i >= 0; i--)
		{
			p->m_iNum--;
			bool bRight = iNum & ((T)1 << i);
			p = p->m_childs[bRight];
		}
		p->m_iNum--;
	}
	T MaxXor(T iNum)
	{
		C2BNumTrieNode* p = m_pRoot;
		T iRet = 0;
		for (int i = iLeveCount - 1; i >= 0; i--)
		{
			bool bRight = !(iNum & ((T)1 << i));
			bool bSel = p->GetNot0Child(bRight);
			p = p->m_childs[bSel];
			if (bSel == bRight)
			{
				iRet |= ((T)1 << i);
			}
		}
		return iRet;
	}
	void Swap(C2BNumTrie<T, iLeveCount>& o) {
		swap(m_pRoot, o.m_pRoot);
		swap(m_setHas, o.m_setHas);
	}
	C2BNumTrieNode* m_pRoot;
	std::unordered_multiset<T> m_setHas;
};

class Solution {
public:
	vector<int> maximizeXor(vector<int>& nums, vector<vector<int>>& queries) {
		const int n = nums.size();
		vector<int> indexs(queries.size());
		iota(indexs.begin(), indexs.end(), 0);
		sort(indexs.begin(), indexs.end(), [&](int i1, int i2) {return queries[i1][1] < queries[i2][1]; });
		sort(nums.begin(), nums.end(),std::greater<int>());
		C2BNumTrie trie;
		vector<int> ret(queries.size());
		for (int i : indexs) {
			while ((nums.size())&&(nums.back() <= queries[i][1])) {
				trie.Add(nums.back());
				nums.pop_back();
			}
			ret[i] = (nums.size()==n ) ? -1 :  trie.MaxXor(queries[i][0]);
		}
		return ret;
	}
};

测试用例

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		assert(v1[i] == v2[i]);
	}
}

template<class T>
void Assert(const T& t1, const T& t2)
{
	assert(t1 == t2);
}

int main()
{
	vector<int> nums;
	vector<vector<int>> queries;
	{
		Solution slu;
		nums = { 3 }, queries = { {2,2} };
		auto res = slu.maximizeXor(nums, queries);
		Assert({ -1 }, res);
	}
	{
		Solution slu;
		nums = { 2 }, queries = { {2,2} };
		auto res = slu.maximizeXor(nums, queries);
		Assert({ 0 }, res);
	}
	{
		Solution slu;
		nums = { 0,1,2,3,4 }, queries = { {3,1},{1,3},{5,6} };
		auto res = slu.maximizeXor(nums, queries);
		Assert({ 3,3,7 }, res);
	}
	{
		Solution slu;
		nums = { 5,2,4,6,6,3 }, queries = { {12,4},{8,1},{6,3} };
		auto res = slu.maximizeXor(nums, queries);
		Assert({ 15,-1,5 }, res);
	}
}

2023年4月版

class C2BNumTrieNode
{
public:
C2BNumTrieNode()
{
m_childs[0] = m_childs[1] = nullptr;
}
bool GetNot0Child(bool bFirstRight)
{
auto ptr = m_childs[bFirstRight];
if (ptr && ( ptr->m_iNum >0 ))
{
return bFirstRight;
}
return !bFirstRight;
}
int m_iNum = 0;
C2BNumTrieNode* m_childs[2] ;
};

template
class C2BNumTrie
{
public:
C2BNumTrie()
{
m_pRoot = new C2BNumTrieNode();
}
void Add(int iNum)
{
C2BNumTrieNode* p = m_pRoot;
for (int i = iLeveNum - 1; i >= 0; i–)
{
p->m_iNum++;
bool bRight = iNum & (1 << i);
if (nullptr == p->m_childs[bRight])
{
p->m_childs[bRight] = new C2BNumTrieNode();
}
p = p->m_childs[bRight];
}
p->m_iNum++;
}
C2BNumTrieNode* m_pRoot;

};
class Solution {
public:
vector maximizeXor(vector& nums, vector<vector>& queries) {
const int iBitNum =30;
std::sort(nums.begin(), nums.end());
vector indexs;
for (int i = 0; i < queries.size(); i++)
{
indexs.emplace_back(i);
}
std::sort(indexs.begin(), indexs.end(), [&](const int& i1, const int& i2)
{
return queries[i1][1] < queries[i2][1];
});
//std::priority_queue<int,vector,greater> queNums(nums.begin(), nums.end());
int iDoNums =0;
C2BNumTrie trie;
vector vRet(indexs.size());
for (int i = 0; i < indexs.size(); i++)
{
const int index = indexs[i];
const int iCur = queries[index][0];
const int iRev = iCur ^ ((1 << iBitNum)- 1);
const int iMax = queries[index][1];
while ((iDoNums < nums.size()) && (nums[iDoNums] <= iMax))
{
trie.Add(nums[iDoNums]);
iDoNums++;
}

		if (0 == trie.m_pRoot->m_iNum)
		{
			vRet[index] = -1;
			continue;
		}
		auto p = trie.m_pRoot;
		int iSel = 0;
		for (int i = iBitNum - 1; i >= 0; i--)
		{
			bool bRight = iRev & (1 << i);
			bool bSel  = p->GetNot0Child(bRight);
			p = p->m_childs[bSel];
			if (bSel)
			{
				iSel |= (1 << i);
			}
		}			
		vRet[index] = iSel^iCur;
	}
	return vRet;
}

};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

闻缺陷则喜何志丹
关注
专栏目录
字典树：421. 数组中两个数的最大异或值
qq_36917571的博客
05-24 339
题目描述 给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。 进阶：你可以在 O(n) 的时间解决这个问题吗？ 示例 1 输入：nums = [3,10,5,25,2,8] 输出：28 解释：最大运算结果是 5 XOR 25 = 28. 示例 2 输入：nums = [0] 输出：0 示例 3 输入：nums = [2,4] 输出：6 示例 4 输入：nums = [8,10,2] 输出：10 示例 5 输入：num
【LeetCode】421. 数组中两个数的最大异或值（哈希集合，字典树，详细图文解释）
Viper的程序员修炼手册
07-02 1087
题目 地址 分析 题目要求 O(N)时间复杂度，下面会讨论两种典型的 O(N) 复杂度解法。 利用哈希集合存储按位前缀。 利用字典树存储按位前缀。 这两种解法背后的思想是一样的，都是先将整数转化成二进制形式，再从最左侧的比特位开始逐一处理来构建最大异或值。两个方法的不同点在于采用了不同的数据结构来存储按位前缀。第一个方法在给定的测试集下执行速度更快，但第二种方法更加普适，更加简单。 异或运算的性质 解决这个问题，我们首先需要利用异或运算的一个性质： 如果 a ^ b = c 成立，那么a ^ c =
1707. 与数组中元素的最大异或值
秃头哥编程
05-25 336
2021-05-23 LeetCode每日一题 链接：https://leetcode-cn.com/problems/maximum-xor-with-an-element-from-array/ 标签：数组、异或、字典树 题目 给你一个由非负整数组成的数组 nums 。另有一个查询数组 queries ，其中 queries[i] = [xi, mi] 。 第 i 个查询的答案是 xi 和任何 nums 数组中不超过 mi 的元素按位异或（XOR）得到的最大值。换句话说，答案是 max(nums[j
数组中两个数的最大异或值（字典树||前缀树）
qq_41884662的博客
05-16 245
class Solution { class Tree{ Tree []son=new Tree[2]; } Tree root=new Tree(); void construct(int x){ Tree child=root; for(int i=30;i>=0;i--){ int t=(x>>i)&1; if(child.son[t]==...
LeetCode 1707 与数组中元素的最大异或值[字典树 异或] HERODING的LeetCode之路
HERODING23的博客
05-23 206
解题思路： 明显不能用暴力法去解决（很可能超时），最妙的方式是字典树，首先把数组中所有元素放入字典树中，然后遍历查询数组与字典树中小的比较，难点一在于找小于阈值的字典树中的位置，第二个是判断当前数是最小数，为了找小于阈值的位置，我们把查询数组按照第二个元素的大小排序，这样字典树每次只插入不大于该数的数字，如果一个都插不进去，说明阈值数太小，直接返回-1，注释已经很详尽了，关注细节的朋友请看代码，代码如下： class Trie { private: // 0或1 Trie* next[2]
【字典树 离线查询 深度优先】1938. 查询最大基因差|2502
闻缺陷则喜何志丹
05-24 1806
给你一棵 n 个节点的有根树，节点编号从 0 到 n - 1 。每个节点的编号表示这个节点的 独一无二的基因值 （也就是说节点 x 的基因值为 x）。两个基因值的 基因差 是两者的 异或和 。给你整数数组 parents ，其中 parents[i] 是节点 i 的父节点。如果节点 x 是树的 根 ，那么 parents[x] == -1 。 给你查询数组 queries ，其中 queries[i] = [nodei, vali] 。对于查询 i ，请你找到 vali 和 pi 的 最大基因差 ，其中 p
【字典树（前缀树） 位运算】1803. 统计异或值在范围内的数对有多少
闻缺陷则喜何志丹
05-24 941
给你一个整数数组 nums （下标 从 0 开始 计数）以及两个整数：low 和 high ，请返回 漂亮数对 的数目。 漂亮数对 是一个形如 (i, j) 的数对，其中 0
leetcode 1707与数组中元素的最大异或值
小嬴布菱的博客
05-24 119
leetcode 刷题 5.23的每日一题题是1707. 与数组中元素的最大异或值，最近异或的题目真滴很多。 这道题可以采用字典树的方法。字典树不太会，先总结在这里吧！ 字典树，又称单词查找树，Trie树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。 字典树的优点：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。 字典树的性质：根节点不包含字符，除根节点外每一个节点都只
字典树(Trie、prefix tree)及其应用（求一个数组中的最大异或值)
gq的博客
10-16 719
trie，又称前缀树或字典树，是一种有序树，用于保存关联数组，其中的键通常是字符串。与二叉查找树不同，键不是直接保存在节点中，而是由节点在树中的位置决定。一个节点的所有子孙都有相同的前缀，也就是这个节点对应的字符串，而根节点对应空字符串。一般情况下，不是所有的节点都有对应的值，只有叶子节点和部分内部节点所对应的键才有相关的值（字符串结尾的那个结点）。trie中的键通常是字符串，但也可以是其它的结构。
xor.zip_puttinge9a_区间异或最大_字典树查找区间异或最大值_寻找最窄区间_异或最大值
09-24
在给定的压缩包文件中，我们可以看到一个名为"xor.zip_puttinge9a_区间异或最大_字典树查找区间异或最大值_寻找最窄区间_异或最大值"的文件，这暗示了使用字典树（Trie）数据结构来解决这一问题。 首先，让我们深入...
前缀树实现最大异或子数组
一只老风铃
01-15 305
问题描述 数组异或和的定义：把数组中所有的数异或起来得到的值。给定一个整型数组arr，其中可能有正、有负，有零，求其中子数组的最大异或和。 输入 4 3 -28 -29 2 输出 7 说明 {-28，-29}这个子数组的异或和为7，是所有子数组中最大的 思路 对于求子数组问题，通常采取动态规划dp[i]=k表示前i项的异或值 那么对于其中的【i=>j】其异或值为dp[j]与dp[i-1]的“异或值做除法" 本题思路是维护一个前缀数组，即字典树形式 计算XOR[]表示前i项的异或值，那么对
数组中两个数异或求最大值
Broken_Wave的博客
08-26 1751
题目：求 n 个非负数中任意 2 个的异或值的最大值。n 数量级为 10^5。 分析：直接暴力求解一定会超时。但是一个字符串可以看成一个32位的01字符串，因此可以建立字典树，建立好树以后对于任意非负整数x，顺着树贪心查找。当前位为0则查找是否存在1，找到0 or 1就继续，找不到就忽略继续查找。 字典树建立和插入时都是将数字倒序插入或查找 字典树介绍：字典树又称单词查找树，Trie 树，是...
牛客OI月赛12-提高组 C. 区间异或和异或区间最大值异或区间最小值（分治+字典树）
积极的防守者的博客
09-28 1771
题目链接 题目大意 给你n个数，对于一个区间[l,r]，xorsum=这个区间所有异或和，min = 区间最小值，max = 区间最大值，要求xorsum ^ min ^ max最大。 解题思路 对于xor最大，我们一般会往两个方向想：一.线性基 二.01字典树 这题是用字典树。如果只是求xorsum最大，我们可以维护一个前缀异或和的字典树，然后每次得到新的前缀异或和，先在字典树查一下能得到的最大...
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现
青山师
11-04 1035
冒泡排序、选择排序、计数排序、插入排序、快速排序、堆排序、归并排序JAVA实现。
【进阶】java基础之集合(2)数据结构＜树＞
最新发布
Y0UZI的博客
11-05 326
二叉查找树，又称二叉排序树或者二叉搜索树。:任意节点左右子树高度差不超过1。
Redis常见面试题：ZSet底层数据结构，SDS、压缩列表ZipList、跳表SkipList
qq_44700578的博客
11-02 980
String类型底层数据结构，List类型全面解析，ZSet底层数据结构；简单动态字符串SDS、压缩列表ZipList、哈希表、跳表SkipList、整数数组IntSet
【数据结构与算法】第8课—数据结构之二叉树(堆)
weixin_70620792的博客
11-02 802
树是一种非线性的数据结构，它是由n(n>=0)个有限节点组成一个具有层次关系的集合，一般是树根朝上，树叶朝下树有一个特殊的节点，叫做根节点，根节点没有前驱节点树的根节点下面又有很多子节点，但是这些子节点是不相交的除根节点外，每棵子树的根节点有且只有一个前驱，但是可以有0个或多个后继，因此，树是递归定义的。
数据结构，问题 F: 括弧匹配检验
nick_912912的博客
11-02 386
假设表达式中允许包含两种括号：圆括号和方括号，其嵌套的顺序随意，如（［ ］（））或［（［ ］［ ］）］等为正确的匹配，［（ ]）或（［ ］（ ）或 ( ( ) ) ）均为错误的匹配。输入一个只包含圆括号和方括号的字符串，判断字符串中的括号是否匹配，匹配就输出 “OK” ，不匹配就输出“Wrong”。匹配就输出 “OK” ，不匹配就输出“Wrong”。现在的问题是，要求检验一个给定表达式中的括弧是否正确匹配？输入仅一行字符（字符个数小于255）输入一个字符串：［（［］［］）］，输出：OK。
8. 数据结构——邻接表、邻接矩阵的基本操作
m0_68536532的博客
11-02 304
【代码】8. 数据结构——邻接表和邻接矩阵的基本操作，包括创建、dfs遍历、bfs遍历、求顶点的出入度。
区间异或最大值的动态寻找与字典树应用
通过字典树，我们可以快速地对数列中每个数的二进制表示进行异或操作，并找出最大值。 而文件标题中提到的“寻找最窄区间”可能是指，在给定的数列中找到长度最小的区间，使得区间内的异或结果大于或等于某个特定值...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值