Leetcode 第 396 场周赛题解

Leetcode 第 396 场周赛题解

题目1：3136. 有效单词

思路

算法：

1. 首先判断字符串 word 的长度，小于 3 则返回 false。
2. word 只由数字 0-9 和英文大小写字母组成，发现其他字符返回 false。
3. digit 标识数字有没有出现过，upper 和 lower 分别标识大写字母和小写字母有没有出现过，cntYuan 和 cntNotYuan 分别统计元音字母和辅音字母的个数。
4. return (digit || upper || lower) && cntYuan > 0 && cntNotYuan > 0 即可。

代码

class Solution
{
private:
	bool isYuan(char &c)
	{
		if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u')
			return true;
		else if (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U')
			return true;
		return false;
	}

public:
	bool isValid(string word)
	{
		if (word.length() < 3)
			return false;
		bool digit = false, upper = false, lower = false;
		int cntYuan = 0, cntNotYuan = 0;
		for (char &c : word)
		{
			if (isdigit(c))
				digit = true;
			else if (isupper(c))
				upper = true;
			else if (islower(c))
				lower = true;
			else
				return false;
			if (isYuan(c))
				cntYuan++;
			if ((isupper(c) || islower(c)) && !isYuan(c))
				cntNotYuan++;
		}
		return (digit || upper || lower) && cntYuan > 0 && cntNotYuan > 0;
	}
};

复杂度分析

时间复杂度：O(n)，其中 n 是字符串 word 的长度。

空间复杂度：O(1)。

题目2：3137. K 周期字符串需要的最少操作次数

思路

根据题意，我们只能选择首字母下标为 0、k、2k、3k、⋯、n−k 的子串来操作（替换），并且这些子串的长度都为 k。

为使操作次数尽量少，我们可以计算最多保留多少个子串不变。也就是统计 word 中的这些首字母下标为 0、k、2k、3k、⋯、n−k 的长为 k 的子串中，出现次数最多的子串的出现次数 maxFreq。用出现次数最多的子串，替换其余子串。

最少操作次数 = 子串个数 - 出现次数最多的子串的出现次数 = n/k - maxFreq。

代码

class Solution
{
public:
	int minimumOperationsToMakeKPeriodic(string word, int k)
	{
		int n = word.length();
		unordered_map<string, int> freq;
		for (int i = 0; i < n; i += k)
		{
			string temp = word.substr(i, k);
			freq[temp]++;
		}
		int maxFreq = 1, total = n / k;
		for (auto &[s, cnt] : freq)
		{
			if (cnt > maxFreq)
				maxFreq = cnt;
		}
		return total - maxFreq;
	}
};

复杂度分析

时间复杂度：O(n)，其中 n 是字符串 word 的长度。

空间复杂度：O(n)，其中 n 是字符串 word 的长度。

题目3：3138. 同位字符串连接的最小长度

思路

从小到大枚举字符串 t 的长度 len。

因为字符串 s 由字符串 t 和它的同位字符串连接而成，所以 n % len = 0。

然后比较所有首字母下标为 0、len、2*len、3*len、⋯、n−len 的长为 len 的子串，所包含的字母及其个数是否一样（同位字符串）。

我的做法是用一个集合 set 保存这些排序后的子串，如果 set.size() > 1，说明不符合要求，直接退出这一次循环。当发现在一次循环中最后 set.size() == 1，说明找到了符合要求的字符串 t，此时的 len 就是同位字符串连接的最小长度。

如果这些因子都不满足要求，答案一定是 n。

代码

class Solution
{
public:
	int minAnagramLength(string s)
	{

		int n = s.length();
		for (int len = 1; len < n; len++)
		{
			if (n % len == 0)
			{
				set<string> set;
				for (int i = 0; i < n; i += len)
				{
					string temp = s.substr(i, len);
					sort(temp.begin(), temp.end());
					set.insert(temp);
					if (set.size() > 1)
						break;
				}
				if (set.size() == 1)
					return len;
			}
		}
		return n;
	}
};

复杂度分析

时间复杂度：O(A*n)，其中 n 是字符串 s 的长度，A 是 n 的因子个数（也就是可枚举的 len 的个数）。

空间复杂度：O(n)，其中 n 是字符串 s 的长度。

题目4：3139. 使数组中所有元素相等的最小开销

思路

分类讨论。

情况1：如果 n≤2，那么只能用操作一，最小总开销为：(M−m)*c₁。

情况二：如果2*c₁<=c₂，用一次操作二不如用两次操作一，所以只需用操作一，把每个数都变成 M 的总开销是最小的。总共需要执行=(M−nums[0])+(M−nums[1])+⋯+(M−nums[n−1])=nM−(nums[0]+nums[1]+⋯+nums[n−1])次操作一。那么最小总开销为(nM−(nums[0]+nums[1]+⋯+nums[n−1]))*c₁。
​
情况三：如果2*c₁>c₂，我们尽量用第二种操作。

枚举目标数 g（由于每个数只能变大不能变小，所以 g≥l），那么第 i 个数需要增加 (g−nums[i])次。问题变为：

设所有桶加起来一共有 s 个石头，最多的桶有 m 个石头，结论为：

• 如果 m>s−m，则最多可以执行 (s−m) 次第二种操作，之后所有石头都只在最多的那个桶里，必须执行 (m−(s−m)) 次第一种操作。
• 如果 m≤s−m，则最多可以执行 ⌊s/2⌋ 次第二种操作，之后如果 s 是奇数那么还会剩下一个石头，执行一次第一种操作即可。

对于第二种情况，操作次数只和 s 有关，那么操作代价也只和 s 有关。所以如果 g=M 时已经是第二种情况了，那么继续增加 g 只会让 s 变得更大，没有意义。

剩下的问题就是，如果 g=M 时还是第一种情况，那么 g 增加到什么时候，一定会进入第二种情况呢？注意到 g 每次增加 1，s 会增加 n，而 m 只会增加 1，那么 m 和 (s−m) 之间的差距会缩小 (n−2)。因为现在讨论的情况中，n 最小是 3，那么 g 每增加 1，两者之间的差距就会缩小 1。由于 m≤s，那么 g 最多增加 m 就一定会进入第二种情况。由于 m≤M，我们只要枚举 g∈[M,2M] 即可。

代码

class Solution
{
private:
	const int MOD = 1e9 + 7;

public:
	int minCostToEqualizeArray(vector<int> &nums, int cost1, int cost2)
	{
		int n = nums.size();
		int maxNum = *max_element(nums.begin(), nums.end());

		// 计算一开始每个桶里有几个石头
		long long diffSum = 0LL;
		int maxDiff = INT_MIN;
		for (int &x : nums)
		{
			int diff = maxNum - x;
			diffSum += diff;
			maxDiff = max(maxDiff, diff);
		}

		// 情况一
		if (n <= 2)
			return (diffSum * cost1) % MOD;
		// 情况二
		if (cost1 * 2 <= cost2)
			return (diffSum * cost1) % MOD;
        // 情况三
		long long ans = LLONG_MAX;
		// 从 maxNum 到 2 * maxNum 枚举目标数
		for (int i = maxNum; i <= 2 * maxNum; i++)
		{
			long long cost = 0LL;
			if (maxDiff > diffSum - maxDiff)
			{
				// 结论一
				cost += (diffSum - maxDiff) * cost2;
				cost += (maxDiff - (diffSum - maxDiff)) * cost1;
			}
			else
			{
				// 结论二
				cost = (diffSum / 2) * cost2;
				if (diffSum % 2 == 1)
					cost += cost1;
			}
			ans = min(ans, cost);
			// 目标数每增加 1，s 增加 n，m 增加 1
			diffSum += n;
			maxDiff++;
		}
		return ans % MOD;
	}
};

复杂度分析

时间复杂度：O(n+M)，其中 n 是数组 nums 的元素个数，M 是数组 nums 的最大值。

空间复杂度：O(1)。