【字典树(前缀树)】1032. 字符流

本文涉及知识点

字典树(前缀树)

LeetCode1032. 字符流

设计一个算法:接收一个字符流,并检查这些字符的后缀是否是字符串数组 words 中的一个字符串。

例如,words = [“abc”, “xyz”] 且字符流中逐个依次加入 4 个字符 ‘a’、‘x’、‘y’ 和 ‘z’ ,你所设计的算法应当可以检测到 “axyz” 的后缀 “xyz” 与 words 中的字符串 “xyz” 匹配。

按下述要求实现 StreamChecker 类:

StreamChecker(String[] words) :构造函数,用字符串数组 words 初始化数据结构。
boolean query(char letter):从字符流中接收一个新字符,如果字符流中的任一非空后缀能匹配 words 中的某一字符串,返回 true ;否则,返回 false。

示例:

输入:
[“StreamChecker”, “query”, “query”, “query”, “query”, “query”, “query”, “query”, “query”, “query”, “query”, “query”, “query”]
[[[“cd”, “f”, “kl”]], [“a”], [“b”], [“c”], [“d”], [“e”], [“f”], [“g”], [“h”], [“i”], [“j”], [“k”], [“l”]]
输出:
[null, false, false, false, true, false, true, false, false, false, false, false, true]

解释:
StreamChecker streamChecker = new StreamChecker([“cd”, “f”, “kl”]);
streamChecker.query(“a”); // 返回 False
streamChecker.query(“b”); // 返回 False
streamChecker.query(“c”); // 返回n False
streamChecker.query(“d”); // 返回 True ,因为 ‘cd’ 在 words 中
streamChecker.query(“e”); // 返回 False
streamChecker.query(“f”); // 返回 True ,因为 ‘f’ 在 words 中
streamChecker.query(“g”); // 返回 False
streamChecker.query(“h”); // 返回 False
streamChecker.query(“i”); // 返回 False
streamChecker.query(“j”); // 返回 False
streamChecker.query(“k”); // 返回 False
streamChecker.query(“l”); // 返回 True ,因为 ‘kl’ 在 words 中

提示:

1 <= words.length <= 2000
1 <= words[i].length <= 200
words[i] 由小写英文字母组成
letter 是一个小写英文字母
最多调用查询 4 * 104

字典树

字典树记录所有words的逆序。
m_vBuf依次记录所有的流。
m = min(200,m_vBuf.size());
for(int i = 0 ; i < m ;i++)
{
查询 m_vBuf.rbegin()+i
}

代码

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 StreamChecker {
public:
	StreamChecker(vector<string>& words) {
		for (const auto& s : words) {
			m_tree.Add(s.rbegin(), s.rend());
		}
	}

	bool query(char letter) {
		m_vBuf.emplace_back(letter);
		const int m = min(200, (int)m_vBuf.size());
		auto ptr = &m_tree.m_root;
		for (int i = 0; i < m; i++) {
			ptr = ptr->GetChild(m_vBuf[m_vBuf.size()-1-i]);
			if (nullptr == ptr) { return false; }
			if (-1 != ptr->m_iLeafIndex) { return true; }
		}
		return false;
	}
	vector<char> m_vBuf;
	CTrie<> m_tree;
};

测试用例

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 = { "cd", "f", "kl" };
	StreamChecker streamChecker(words);
	Assert(false, streamChecker.query('a')); // 返回 False
	Assert(false, streamChecker.query('b')); // 返回 False
	Assert(false, streamChecker.query('c')); // 返回n False
	Assert(true, streamChecker.query('d')); // 返回 True ,因为 ‘cd’ 在 words 中
	Assert(false, streamChecker.query('e')); // 返回 False
	Assert(true, streamChecker.query('f')); // 返回 True ,因为 ‘f’ 在 words 中
	Assert(false, streamChecker.query('g')); // 返回 False
	Assert(false, streamChecker.query('h')); // 返回 False
	Assert(false, streamChecker.query('i')); // 返回 False
	Assert(false, streamChecker.query('j')); // 返回 False
	Assert(false, streamChecker.query('k')); // 返回 False
	Assert(true, streamChecker.query('l')); // 返回 True ,因为 ‘kl’ 在 words 中
	
}

2023年5月

template
class CTrie2Node
{
public:
CTrie2Node()
{
memset(m_childs, 0, sizeof(m_childs));
}
~CTrie2Node()
{
for (int i = 0; i < iCodeNum; i++)
{
delete m_childs[i];
m_childs[i] = nullptr;
}
}
CTrie2Node* GetOrAddChild(const char& ch)
{
const int index = ch - cBegin;
if (nullptr == m_childs[index])
{
m_childs[index] = new CTrie2Node();
}
return m_childs[index];
}
CTrie2Node* GetChild(const char& ch)
{
const int index = ch - cBegin;
return m_childs[index];
}
bool m_bEnd=false;
private:
CTrie2Node* m_childs[iCodeNum];
};

template
class CTrie2
{
public:
template
void Add(IT begin, IT end)
{
auto p = &m_root;
for (; begin != end; ++begin)
{
p = p->GetOrAddChild(*begin);
}
p->m_bEnd = true;
}
bool Search(const char& ch)
{
m_vChar.emplace_back(ch);
auto p = &m_root;
for (auto it = m_vChar.rbegin(); it != m_vChar.rend(); ++it)
{
p = p->GetChild(*it);
if (nullptr == p)
{
return false;
}
if (p->m_bEnd)
{
return true;
}
}
return false;
}
CTrie2Node<iCodeNum, cBegin> m_root;
vector m_vChar;
};

class StreamChecker {
public:
StreamChecker(vector& words) {
for (const auto& str:words)
{
m_trie.Add(str.rbegin(), str.rend());
}
}
bool query(char letter) {
return m_trie.Search(letter);
}
CTrie2<> m_trie;
};
/**

  • Your StreamChecker object will be instantiated and called as such:
  • StreamChecker* obj = new StreamChecker(words);
  • bool param_1 = obj->query(letter);
    */

扩展阅读

视频课程

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

  • 28
    点赞
  • 43
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

闻缺陷则喜何志丹

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

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

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

打赏作者

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

抵扣说明:

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

余额充值