【字典树 马拉车算法】336. 回文对

news2024/11/16 23:22:33

本文涉及知识点

字典树 马拉车算法

336. 回文对

给定一个由唯一字符串构成的 0 索引 数组 words 。
回文对 是一对整数 (i, j) ，满足以下条件：
0 <= i, j < words.length，i != j ，并且words[i] + words[j]（两个字符串的连接）是一个回文串
。
返回一个数组，它包含 words 中所有满足 回文对 条件的字符串。
你必须设计一个时间复杂度为 O(sum of words[i].length) 的算法。
示例 1：
输入：words = [“abcd”,“dcba”,“lls”,“s”,“sssll”]
输出：[[0,1],[1,0],[3,2],[2,4]]
解释：可拼接成的回文串为 [“dcbaabcd”,“abcddcba”,“slls”,“llssssll”]
示例 2：
输入：words = [“bat”,“tab”,“cat”]
输出：[[0,1],[1,0]]
解释：可拼接成的回文串为 [“battab”,“tabbat”]
示例 3：
输入：words = [“a”,“”]
输出：[[0,1],[1,0]]
提示：
1 <= words.length <= 5000
0 <= words[i].length <= 300
words[i] 由小写英文字母组成。

字典树

n = words.length
字典数tree 各叶子记录符合当前字符串的索引，由于是唯一字符串，所以不可能有相同字符串。
令words2[i]是wrods[i]的逆序。令tree2是words2的字典树。
x1 = words[i].lenght x2=words[j].length
如果 x1 == x2 相等。则words[j]的逆向在字典树存在。注意：i ≠ \neq =j
如果 x1 < x2 。则：令words2[j][x1-1]对应叶子节点wrods[i]，且words2[i][x…]是回文。则[i,j]是回文对。
如果x1 > x2。word[i][x2-1]在tree中对应节点j。words[i][x2…]是回文。
判断回文如果用中心扩展：一个字符串的时间复杂度是O(mm) m = words[i].length
总时间复杂就成了：O(nmm) 超时。
只能用马拉车算法。

内存非常容易超，第一个版本用了两个字典树，空间就超了。换成一个字典树才勉强过。

代码

核心代码

//马拉车计算回文回文
class CPalindrome
{
public:
	void  CalCenterHalfLen(const string& s)
	{
		vector<char> v = { '*' };
		for (const auto& ch : s)
		{
			v.emplace_back(ch);
			v.emplace_back('*');
		}

		const int len = v.size();
		vector<int> vHalfLen(len);
		int center = -1, r = -1;
		//center是对称中心,r是其右边界（闭）
		for (int i = 0; i < len; i++)
		{
			int tmp = 1;
			if (i <= r)
			{
				int pre = center - (i - center);
				tmp = min(vHalfLen[pre], r - i + 1);
			}
			for (tmp++; (i + tmp - 1 < len) && (i - tmp + 1 >= 0) && (v[i + tmp - 1] == v[i - tmp + 1]); tmp++);
			vHalfLen[i] = --tmp;
			const int iNewR = i + tmp - 1;
			if (iNewR > r)
			{
				r = iNewR;
				center = i;
			}
		}

		m_vOddCenterHalfLen.resize(s.length());
		m_vEvenCenterHalfLen.resize(s.length());
		for (int i = 1; i < len; i++)
		{
			const int center = (i - 1) / 2;
			const int iHalfLen = vHalfLen[i] / 2;
			if (i & 1)
			{//原字符串奇数长度
				m_vOddCenterHalfLen[center] = iHalfLen;
			}
			else
			{
				m_vEvenCenterHalfLen[center] = iHalfLen;
			}
		}
	}
	vector<int> m_vOddCenterHalfLen, m_vEvenCenterHalfLen;//vOddHalfLen[i]表示 以s[i]为中心，且长度为奇数的最长回文的半长，包括s[i]
	//比如："aba" vOddHalfLen[1]为2 "abba" vEvenHalfLen[1]为2
};

template<class TData = char, int iTypeNum = 26, TData cBegin = 'a'>
class CTrieNode
{
public:
	~CTrieNode()
	{
		for (auto& [tmp, ptr] : m_dataToChilds) {
			delete ptr;
		}
	}
	CTrieNode* AddChar(TData ele, int& iMaxID)
	{
#ifdef _DEBUG
		if ((ele < cBegin) || (ele >= cBegin + iTypeNum))
		{
			return nullptr;
		}
#endif
		const int index = ele - cBegin;
		auto ptr = m_dataToChilds[ele - cBegin];
		if (!ptr)
		{
			m_dataToChilds[index] = new CTrieNode();
#ifdef _DEBUG
			m_dataToChilds[index]->m_iID = ++iMaxID;
			m_childForDebug[ele] = m_dataToChilds[index];
#endif
		}
		return m_dataToChilds[index];
	}
	CTrieNode* GetChild(TData ele)
	{
#ifdef _DEBUG
		if ((ele < cBegin) || (ele >= cBegin + iTypeNum))
		{
			return nullptr;
		}
#endif
		return m_dataToChilds[ele - cBegin];
	}
protected:
#ifdef _DEBUG
	int m_iID = -1;
	std::unordered_map<TData, CTrieNode*> m_childForDebug;
#endif
public:
	int m_iLeafIndex = -1;
protected:
	//CTrieNode* m_dataToChilds[iTypeNum] = { nullptr };//空间换时间 大约216字节
	//unordered_map<int, CTrieNode*>    m_dataToChilds;//时间换空间 大约56字节
	map<int, CTrieNode*>    m_dataToChilds;//时间换空间,空间略优于哈希映射，数量小于256时，时间也优。大约48字节
};
template<class TData = char, int iTypeNum = 26, TData cBegin = 'a'>
class CTrie
{
public:
	int GetLeadCount()
	{
		return m_iLeafCount;
	}
	CTrieNode<TData, iTypeNum, cBegin>* AddA(CTrieNode<TData, iTypeNum, cBegin>* par,TData curValue)
	{
		auto curNode =par->AddChar(curValue, m_iMaxID);
		FreshLeafIndex(curNode);
		return curNode;
	}
	template<class IT>
	int Add(IT begin, IT end)
	{
		auto pNode = &m_root;
		for (; begin != end; ++begin)
		{
			pNode = pNode->AddChar(*begin, m_iMaxID);
		}
		FreshLeafIndex(pNode);
		return pNode->m_iLeafIndex;
	}	
	template<class IT>
	CTrieNode<TData, iTypeNum, cBegin>* Search(IT begin, IT end)
	{
		auto ptr = &m_root;
		for (; begin != end; ++begin)
		{
			ptr = ptr->GetChild(*begin);
			if (nullptr == ptr)
			{
				return nullptr;
			}
		}
		return ptr;
	}
	CTrieNode<TData, iTypeNum, cBegin> m_root;
protected:
	void FreshLeafIndex(CTrieNode<TData, iTypeNum, cBegin>* pNode)
	{
		if (-1 == pNode->m_iLeafIndex)
		{
			pNode->m_iLeafIndex = m_iLeafCount++;
		}
	}
	int m_iMaxID = 0;
	int m_iLeafCount = 0;
};

class Solution {
public:
	vector<vector<int>> palindromePairs(vector<string>& words) {
		{
			CTrie<> tree;
			for (const auto& s : words) {				
				tree.Add(s.rbegin(), s.rend());
			}
			for (int i = 0; i < words.size(); i++) {
				const auto& s = words[i];
				auto ptr = tree.Search(s.begin(), s.end());
				if ((nullptr != ptr) && (-1 != ptr->m_iLeafIndex) && (i != ptr->m_iLeafIndex)) {
					m_vRet.emplace_back(vector<int>{ i, ptr->m_iLeafIndex });
				}
			}
			for (int i = 0; i < words.size(); i++) {
				const auto& s = words[i];
				CPalindrome p1;
				p1.CalCenterHalfLen(s);
				Do(s,i, &tree.m_root, p1, false);
			}
		}

		{
			CTrie<> tree;
			for (const auto& s : words) {
				tree.Add(s.begin(), s.end());
			}
			for (int i = 0; i < words.size(); i++) {
				string s (words[i].rbegin(), words[i].rend());
				CPalindrome p1;
				p1.CalCenterHalfLen(s);
				Do(s, i, &tree.m_root, p1, true);
			}
		}		
		return m_vRet;
	}
	void Do  (const std::string& s, int i ,CTrieNode<char, 26, (char)97>* ptr1, CPalindrome& p1, bool bRev)
	{
		for (int j = 0; j < s.length(); j++) {
			if (nullptr == ptr1) { break; }
			if (-1 != ptr1->m_iLeafIndex) {
				const int len = s.length() - j;
				const int needHalfLen = (len + 1) / 2;
				bool bOdd = 1 & (len);
				auto center = (j + s.length() - 1) / 2;
				const auto& iHalfLen = bOdd ? p1.m_vOddCenterHalfLen[center] : p1.m_vEvenCenterHalfLen[center];
				if (iHalfLen >= needHalfLen) {
					if (bRev) {
						m_vRet.emplace_back(vector<int>{ ptr1->m_iLeafIndex, i});
					}
					else {
						m_vRet.emplace_back(vector<int>{i, ptr1->m_iLeafIndex});
					}
				}
			}
			ptr1 = ptr1->GetChild(s[j]);
		}
	};
	vector<vector<int>> m_vRet;
};

测试用例

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

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]);
	}

}

int main()
{
	vector<string> words;
	{
		Solution sln;
		words = { "bat","tab","cat" };
		auto res = sln.palindromePairs(words);
		Assert(res, { {0,1},{1,0} });
	}
	{
		Solution sln;
		words = { "a","" };
		auto res = sln.palindromePairs(words);
		Assert(res, { {0,1},{1,0} });
	}
	{
		Solution sln;
		words = { "abcd","dcba","lls","s","sssll" };
		auto res = sln.palindromePairs(words);
		Assert(res, { {0,1},{1,0},{3,2},{2,4} });
	}

	
}

2023年哈希

class Solution {
public:
	vector<vector<int>> palindromePairs(vector<string>& words) {
		vector<int> indexs;
		for (int i = 0; i < words.size(); i++)
		{
			indexs.emplace_back(i);
		}
		std::sort(indexs.begin(), indexs.end(), [&](const int& i1,const int& i2)
		{
			return words[i1].length() < words[i2].length();
		});
		vector<vector<int>> vRet;
		std::unordered_map<string, int> mStrIndexs;
		int iEmptyStrindex = -1;
		for (int ii = 0; ii < words.size(); ii++)
		{
			const int i = indexs[ii];
			const string& word = words[i];
			
			string strRev(word.rbegin(), word.rend());
			const int iUpper = word.length() - 1;
			const char* pRev = strRev.c_str() +  1;

			{//左边是回文
				vector<char> vRevRight(word.rbegin(), word.rend());
				C2DynaHashStr<> hs(26), hsRev(26);
				for (int j = 0; j < word.size(); j++)
				{
					hs.push_back(word[j]);
					hsRev.push_front(word[j]);
					if (hs == hsRev)
					{
						vRevRight[iUpper - j] = '\0';
						if (mStrIndexs.count(vRevRight.data()))
						{
							vRet.emplace_back(vector<int>{ mStrIndexs[vRevRight.data()], i});
						}
					}
				}
			}
			{
				C2DynaHashStr<> hs(26), hsRev(26);
				for (int j = word.size() - 1; j >= 0; j--)
				{
					hs.push_back(word[j]);
					hsRev.push_front(word[j]);
					if (hs == hsRev)
					{
						if (mStrIndexs.count(pRev))
						{
							vRet.emplace_back(vector<int>{i, mStrIndexs[pRev]});
						}
					}
					pRev++;
				}
			}
	
			{

				if (mStrIndexs.count(strRev))
				{
					vRet.emplace_back(vector<int>{i, mStrIndexs[strRev]});
					vRet.emplace_back(vector<int>{ mStrIndexs[strRev], i});
				}
			}
			mStrIndexs[word] = i;
		}

		sort(vRet.begin(), vRet.end());
		return vRet;
	}
	bool Check(const string& str,C2HashStr<>& hs, C2HashStr<>& hsRev, int left, int r)
	{
		/*
		while (l < r)
		{
			if (str[l] != str[r])
			{
				return false;
			}
			l++;
			r--;
		}
		*/
		const int iUpper = str.length() - 1;
		return hs.GetHash(left, r) == hsRev.GetHash(iUpper - r, iUpper - left);
	}
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步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++**实现。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1692907.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CAN网络管理（TJA1145如何实现MCU的休眠唤醒）

CAN网络管理（TJA1145如何实现MCU的休眠唤醒）

节点唤醒方式 本地唤醒&#xff1a; 唤醒源来源于自身模块&#xff0c;比如常说的KL15&#xff0c;控制器由KL15线供电&#xff0c;即只能在钥匙置于“ACC”或者“ON”档时运行软件和维持CAN通信 对于正在运行的CPU软件&#xff0c;无论它处在什么状态&#xff0c;只要Hardwa…
阅读更多...
【Tools】微服务工程中的通用功能模块抽取

【Tools】微服务工程中的通用功能模块抽取

Catalog 通用功能模块抽取一、需求二、步骤三、细节 通用功能模块抽取 一、需求 在微服务工程中&#xff0c;可能有一些工具类、实体类是多个微服务通用的&#xff0c;如果在每个微服务中都复制粘贴这些工具类&#xff0c;会产生很多重复性的代码&#xff0c;对开发来说也很繁…
阅读更多...
吴恩达2022机器学习专项课程C2W2：实验Relu激活函数

吴恩达2022机器学习专项课程C2W2：实验Relu激活函数

目录 代码修改1.Activation2.Dense3.代码顺序 新的内容1.总结上节课内容2.展示ReLU激活函数的好处3.结论 代码案例一代码案例二1.构建数据集2.构建模型 2D1.构建数据集2.模型预测3.扩展 代码修改 1.Activation &#xff08;1&#xff09;需要添加代码from tensorflow.keras i…
阅读更多...
5.小程序页面布局 - 记账页面(名目布局、绘制键盘、引用picker时间选择组件)

5.小程序页面布局 - 记账页面(名目布局、绘制键盘、引用picker时间选择组件)

文章目录 1. 小程序页面布局 - 记账页面1.1. 记账页面的布局1.1.1. 样例1.1.2. 页面解构1.1.3. 内容布局的实现1.1.3.1. 填坑(display:flex)1.1.3.2. 突破(display:grid)1.1.3.3. 应用 1.1.4. 点击图片加背景色1.1.5. 添加一个键盘1.1.6. 日期选择组件 1. 小程序页面布局 - 记账…
阅读更多...
Liunx基本指令以及权限（个人笔记）

Liunx基本指令以及权限（个人笔记）

Linux指令和权限 1.指令1.1ls指令1.2pwd命令1.3cd指令1.4touch指令1.5mkdir指令1.6rm指令1.7man指令1.8cp指令1.9mv指令1.10cat指令1.11less指令1.12head指令1.13tail指令1.14date显示1.15Cal指令1.16find指令1.17grep指令1.18zip/unzip指令1.19tar指令1.20bc指令1.21uname -r指…
阅读更多...
SQLServer表变量

SQLServer表变量

表变量是本地变量的一种特殊类型&#xff0c;它有助于临时存储数据; 要声明表变量&#xff0c;使用declare,而局部变量的名称必须以符号开头&#xff1b; TABLE关键字指定此变量是表变量&#xff0c;然后还要定义列名和数据类型&#xff1b; 下面定义一个表变量&#xff0c…
阅读更多...
光伏项目怎么做预算？

光伏项目怎么做预算？

随着可再生能源行业的蓬勃发展&#xff0c;光伏行业也得到了扩张。许多想要加入光伏项目投资的人&#xff0c;都在为怎样为项目做预算而苦恼&#xff0c;今天我就来跟大家分析下可以怎么做。 一、了解市场需求&#xff0c;确定预算目标 在制定光伏项目预算方案之前&#xff0c…
阅读更多...
Vue CLI 的服务介绍与使用（2024-05-20）

Vue CLI 的服务介绍与使用（2024-05-20）

1、介绍 Vue CLI 是一个基于 Vue.js 进行快速开发的完整系统&#xff0c;提供&#xff1a; 通过 vue/cli 实现的交互式的项目脚手架。 通过 vue/cli vue/cli-service-global 实现的零配置原型开发。 一个运行时依赖 (vue/cli-service)&#xff0c;该依赖&#xff1a; 可升级…
阅读更多...
docker-如何将容器外的脚本放入容器内，将容器内的脚本放入容器外

docker-如何将容器外的脚本放入容器内，将容器内的脚本放入容器外

文章目录 前言docker-如何将容器外的脚本放入容器内&#xff0c;将容器内的脚本放入容器外、1. docker 如何将容器外的脚本放入容器内1.1. 验证 2. 将容器内的脚本放入容器外 前言 如果您觉得有用的话&#xff0c;记得给博主点个赞&#xff0c;评论&#xff0c;收藏一键三连啊&…
阅读更多...
JKI State Machine的特点与详细介绍

JKI State Machine的特点与详细介绍

JKI State Machine是一种基于状态机的LabVIEW架构&#xff0c;由JKI公司开发。它广泛用于开发复杂的应用程序&#xff0c;提供了一种灵活且可扩展的结构&#xff0c;适用于多种任务的管理和执行。其设计目标是提高开发效率、代码可读性和可维护性。 2. 基本架构 JKI State Ma…
阅读更多...
Spring Boot 中缓存的用法

Spring Boot 中缓存的用法

缓存&#xff08;Caching&#xff09;是提升应用性能的重要手段之一&#xff0c;通过减少不必要的数据计算和数据库访问&#xff0c;显著提高系统的响应速度。在 Spring Boot 中&#xff0c;缓存机制被集成得非常好&#xff0c;使得我们能够快速、方便地使用缓存功能。本文将介…
阅读更多...
基于Android studio 订餐、外卖系统

基于Android studio 订餐、外卖系统

目录 项目介绍 图片展示 运行环境 获取方式 项目介绍 具有登录&#xff0c;注册&#xff0c;修改密码&#xff0c;查看关于开发信息(可以填写自己的信息) 我的&#xff1a;可以查看菜品详情&#xff0c;填写份数&#xff0c;加入购物车&#xff0c; 购物车&#xff1a;可…
阅读更多...
【IDEA软件应用篇】IDEA基础开发设置和开发快捷键

【IDEA软件应用篇】IDEA基础开发设置和开发快捷键

IDEA是一种集成开发环境&#xff0c;可以运行java代码。 本篇文章你将收获到下面的知识&#xff1a; &#xff08;1&#xff09;IDEA如何设置字体大小快捷键 &#xff08;2&#xff09;如何解决每次进IDEA时&#xff0c;进去的页面都是上次使用完时的那个页面 &#xff08;3&am…
阅读更多...
使用yum下载rpm包

使用yum下载rpm包

1、命令格式 yum install --downloadonly --downloaddir<directory> <package-name> --downloadonly&#xff1a;只下载选项而不进行安培训--downloaddir&#xff1a;指定下载目录&#xff0c;默认下载的RPM包会保在/var/cache/yum/x86_64/[centos|fedora-versio…
阅读更多...
Linux系统下Mysql忘记密码怎么解决

Linux系统下Mysql忘记密码怎么解决

一、对Mysql配置文件进行设置 1、找到/etc/mysql/my.cnf路径下&#xff0c;用Vi命令编辑my.cnf配置文件&#xff0c;命令如下&#xff1a; # 以管理员身份登录 sudo su # 输入管理员密码 # 登录成功后&#xff0c;找到Mysql的配置文件-->Mysql配置文件默认在此 cd /etc/my…
阅读更多...
异相（相位不平衡）状态下的合成器效率分析-理论与ADS仿真

异相（相位不平衡）状态下的合成器效率分析-理论与ADS仿真

异相&#xff08;相位不平衡&#xff09;状态下的合成器效率分析-理论与ADS仿真 12、ADS使用记录之功分器设计中简单介绍了威尔金森功分器的设计方法。一般来讲&#xff0c;功分器反过来就能作为合路器使用&#xff0c;在输入信号相位一致的情况下&#xff0c;各种合路器的效率…
阅读更多...
YOLOv8独家改进：mamba系列 | 视觉态空间（VSS）块结合C2f二次创新，提升捕捉广泛的上下文信息 | VMamba2024年最新成果

YOLOv8独家改进：mamba系列 | 视觉态空间（VSS）块结合C2f二次创新，提升捕捉广泛的上下文信息 | VMamba2024年最新成果

💡💡💡创新点：Mamba UNet采用了纯基于视觉Mamba（VMamba）的编码器-解码器结构，融入了跳跃连接，以保存网络不同规模的空间信息。这种设计有助于全面的特征学习过程，捕捉医学图像中复杂的细节和更广泛的语义上下文。我们在VMamba块中引入了一种新的集成机制，以确保编…
阅读更多...
Linux之共享内存mmap用法实例(六十三)

Linux之共享内存mmap用法实例(六十三)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
通过注意力调节实现更好的文本到图像生成对齐

通过注意力调节实现更好的文本到图像生成对齐

近年来&#xff0c;生成性AI技术在众多领域取得了前所未有的进步。大规模预训练模型的出现激发了各种下游任务中的新应用。这在文本到图像生成领域尤为明显&#xff0c;例如Stable Diffusion、DALL-E 2和Imagen等模型已经显著展示了它们的能力。尽管如此&#xff0c;复杂提示中…
阅读更多...
Go语言的pprof工具是如何使用的？

Go语言的pprof工具是如何使用的？

文章目录 Go语言的pprof工具详解pprof的使用runtime/pprofnet/http/pprof 快速开始获取采样数据通过pprof工具进行性能分析总结 Go语言的pprof工具详解 Go语言作为一个高性能、高并发的编程语言&#xff0c;对性能优化有着极高的要求。在Go语言的标准库中&#xff0c;pprof是一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023