【单调栈】LeetCode2030:含特定字母的最小子序列

作者推荐

map|动态规划|单调栈|LeetCode975:奇偶跳

涉及知识点

单调栈

题目

给你一个字符串 s ，一个整数 k ，一个字母 letter 以及另一个整数 repetition 。
返回 s 中长度为 k 且字典序最小的子序列，该子序列同时应满足字母 letter 出现至少 repetition 次。生成的测试用例满足 letter 在 s 中出现至少 repetition 次。
子序列是由原字符串删除一些（或不删除）字符且不改变剩余字符顺序得到的剩余字符串。
字符串 a 字典序比字符串 b 小的定义为：在 a 和 b 出现不同字符的第一个位置上，字符串 a 的字符在字母表中的顺序早于字符串 b 的字符。
示例 1：
输入：s = “leet”, k = 3, letter = “e”, repetition = 1
输出：“eet”
解释：存在 4 个长度为 3 ，且满足字母 ‘e’ 出现至少 1 次的子序列：

“lee”（“leet”）
“let”（“leet”）
“let”（“leet”）
“eet”（“leet”）
其中字典序最小的子序列是 “eet” 。
示例 2：
输入：s = “leetcode”, k = 4, letter = “e”, repetition = 2
输出：“ecde”
解释：“ecde” 是长度为 4 且满足字母 “e” 出现至少 2 次的字典序最小的子序列。
示例 3：
输入：s = “bb”, k = 2, letter = “b”, repetition = 2
输出：“bb”
解释：“bb” 是唯一一个长度为 2 且满足字母 “b” 出现至少 2 次的子序列。
参数范围：
1 <= repetition <= k <= s.length <= 5 * 10⁴
s 由小写英文字母组成
letter 是一个小写英文字母，在 s 中至少出现 repetition 次

单调栈

最简单的情况：不限制长度和重复字符

从左到右将s[i]放到栈中，放入之前向将栈中大于s[i]的出栈。下面来证明：
假定s的最小子系列的为依次为：{i1,i2,i3…}。
规则一：i1之前没有数小于等于它。否则将此数的放在最前会变得最小。
规则二：i1之后没有数小于它，否则替换i1会变得更小。
规则三：i1和i2之间没有数小于等于i2。
规则四：i2之后没有数小于它，否则替换i2会变得更小。
…
栈底到栈顶就是最小子系列。
i1在栈底，说明它前面的数都大于它，所以出栈了。
i1没有出栈，说明i1之后没有数比它小，否则i1出栈了。
i2之前，i1之后没有数据，说明两者之间没有数小于等于i2，否则不会出栈。
i2没有出栈说明之后没有数据小于它，否则出栈了。
…

大数出栈后，变成前面的数小，后面的数大。也就是递增的单调栈。

注意: {1,1,1} 前面增加1，变成{1,1,1,1} 有些规则可能变小，有些规则可能变大。

限制长度k

限制了长度，也就限制了出栈次数。前面的数变小比后面的数变小更小，所以把出栈的机会留给前面。
出栈的时候增加判断：如果出栈后，使得长度一定少于k则不出栈。
入栈的时候增加判断：如果长度已经为k，则不入栈。

必须特定个特定字母

如果出栈会造成特定字母不足则不出栈。
入栈时增加处理：如果长度为k，但当前是特定字母，不入栈则特定字母不足，出栈栈顶所有特定字母，直到非特定字母。出栈它，把出栈的特定字母和当前字母入栈。这个操作在超时的边缘。

代码

核心代码

class Solution {
public:
	string smallestSubsequence(const string s, const int k, const char letter, const int repetition) {
		int iCanOutCount = std::count(s.begin(), s.end(), letter) - repetition;//可以不使用letter的数量
		vector<char> sta;
		for (int i = 0; i < s.length(); i++)
		{
			const auto& ch = s[i];
			auto NeedPop = [&]()
			{
				if (sta.empty() || (sta.size() + s.length() - i <= k) || (sta.back() <= ch))
				{
					return false;
				}
				if ((sta.back() == letter) && (iCanOutCount <= 0))
				{
					return false;
				}
				return true;
			};
			while (NeedPop())
			{
				iCanOutCount -= (sta.back() == letter);
				sta.pop_back();
			}
			if (sta.size() < k)
			{
				sta.emplace_back(ch);
			}
			else if ((letter == ch)&&( iCanOutCount <= 0 ))
			{
				int iCnt = 1;
				while (sta.size()+ iCnt > k )
				{
					if (letter == sta.back())
					{
						iCnt++;
					}
					sta.pop_back();
				}
				while (iCnt--)
				{
					sta.emplace_back(letter);
				}
			}
			else
			{
				iCanOutCount -= (letter == ch);
			}
		}
		sta.emplace_back(0);
		return sta.data();
	}
};

测试用例

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()
{
	string s;
	int k;
	char letter;
	int repetition;
	{
		Solution slu;
		s = "leet", k = 3, letter = 'e', repetition = 1;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("eet"), res);
	}
	{
		Solution slu;
		s = "leetcode", k = 4, letter = 'e', repetition = 2;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("ecde"), res);
	}
	{
		Solution slu;
		s = "bb", k = 2, letter ='b', repetition = 2;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("bb"), res);
	}
	{
		Solution slu;
		s = "aaabbbcccddd", k = 3, letter = 'b', repetition = 2;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("abb"), res);
	}
	{
		Solution slu;
		s = "hjjhhhmhhwhz", k = 6, letter = 'h', repetition = 5;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("hhhhhh"), res);
	}

	
	//CConsole::Out(res);
}

优化

非特定字母最多入栈：k - repetition。注意：非特定字母入栈的时候，也要判断栈的长度小于k。

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()
{
	string s;
	int k;
	char letter;
	int repetition;
	{
		Solution slu;
		s = "leet", k = 3, letter = 'e', repetition = 1;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("eet"), res);
	}
	{
		Solution slu;
		s = "leetcode", k = 4, letter = 'e', repetition = 2;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("ecde"), res);
	}
	{
		Solution slu;
		s = "bb", k = 2, letter ='b', repetition = 2;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("bb"), res);
	}
	{
		Solution slu;
		s = "aaabbbcccddd", k = 3, letter = 'b', repetition = 2;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("abb"), res);
	}
	{
		Solution slu;
		s = "hjjhhhmhhwhz", k = 6, letter = 'h', repetition = 5;
		auto res = slu.smallestSubsequence(s, k, letter, repetition);
		Assert(std::string("hhhhhh"), res);
	}

	
	//CConsole::Out(res);
}

2023年3月旧版

class Solution {
public:
string smallestSubsequence(string s, int k, const char letter, int repetition) {
m_c = s.length();
int iCanNotUseLetterNum = -repetition;//可以不使用letter多少次
int iCanNotUseChar = m_c - k;
vector vAns;
for (const auto& ch : s)
{
if (ch == letter)
{
iCanNotUseLetterNum++;
}
}
for (int i = 0; i < m_c; i++)
{
const auto& ch = s[i];
while (vAns.size() && (ch < vAns.back()) && iCanNotUseChar && ((letter != vAns.back()) || iCanNotUseLetterNum))
{
if (letter == vAns.back())
{
iCanNotUseLetterNum–;
}
iCanNotUseChar–;
vAns.pop_back();
}
vAns.push_back(ch);
}
string strRet;
for (int iIndex = vAns.size() - 1; iIndex >= 0; iIndex–)
{
const char& ch = vAns[iIndex];
if (0 == iCanNotUseChar)
{
strRet += ch;
continue;
}
if (letter == ch )
{
if (iCanNotUseLetterNum)
{
iCanNotUseLetterNum–;
iCanNotUseChar–;
}
else
{
strRet += ch;
}
}
else
{
iCanNotUseChar–;
}
}
vector tmp(strRet.rbegin(), strRet.rend());
tmp.push_back(0);
return tmp.data();
}
int m_c;
};

扩展阅读

视频课程

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

如何你想快

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

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛