一，题目详情
1，问题描述
小D拿到了一个仅由 "abc" 三种字母组成的字符串。她每次操作会对所有字符同时进行以下变换：
- 将 'a' 变成 'bc'
- 将 'b' 变成 'ca'
- 将 'c' 变成 'ab'
小D将重复该操作 k 次。你的任务是输出经过 k 次变换后，得到的最终字符串。
例如：对于初始字符串 "abc"，执行 2 次操作后，字符串将变为 "caababbcbcca"。
2，测试样例
样例1：
输入：s = "abc", k = 2
输出：'caababbcbcca'
样例2：
输入：s = "abca", k = 3
输出：'abbcbccabccacaabcaababbcabbcbcca'
样例3：
输入：s = "cba", k = 1
输出：'abcabc'
二，解题思路
1，问题分析
我们需要模拟字符串经过 k 次变换后的结果。每次变换会将每个字符替换为两个字符，因此字符串长度会呈指数增长。
2，算法策略
核心思想是：对于每个字符，经过 k 次变换后，会生成 2^k 个字符。我们可以通过数学规律直接计算每个字符的变换结果，而不需要逐次模拟。
具体步骤如下：
- 对于每个字符 c，计算其初始数值（'a' 为 0，'b' 为 1，'c' 为 2）。
- 计算 (c_val + k) mod 3，得到基础偏移量 x。
- 生成所有可能的 2^k 种组合，每种组合对应一个二进制数 m（从 0 到 2^k - 1）。
- 对于每个组合 m，计算其中 1 的个数 t，然后计算 (x + t) mod 3，得到对应的字符。
- 将所有字符组合成字符串，作为该字符的变换结果。
- 将所有字符的变换结果拼接起来，得到最终字符串。
3，逐步推演（以样例1为例）
输入：s = "abc", k = 2
对于每个字符：
-
'a'：
- c_val = 0
- x = (0 + 2) % 3 = 2
- 生成 4 种组合（m=0,1,2,3），对应的 t 分别为 0,1,1,2
- 字符分别为：(2+0)%3=2 → 'c', (2+1)%3=0 → 'a', (2+1)%3=0 → 'a', (2+2)%3=1 → 'b'
- 变换结果为 'caab'
-
'b'：
- c_val = 1
- x = (1 + 2) % 3 = 0
- 生成 4 种组合，对应的 t 分别为 0,1,1,2
- 字符分别为：0 → 'a', 1 → 'b', 1 → 'b', 2 → 'c'
- 变换结果为 'abbc'
-
'c'：
- c_val = 2
- x = (2 + 2) % 3 = 1
- 生成 4 种组合，对应的 t 分别为 0,1,1,2
- 字符分别为：1 → 'b', 2 → 'c', 2 → 'c', 3%3=0 → 'a'
- 变换结果为 'bcca'
最终结果为 'caab' + 'abbc' + 'bcca' = 'caababbcbcca'。
三，代码实现
def solution(s: str, k: int) -> str:
result = []
for c in s:
# 计算字符的初始数值
c_val = ord(c) - ord('a')
# 计算 (c_val + k) mod 3
x = (c_val + k) % 3
# 生成该字符经过k次变换后的字符串
transformed = []
for m in range(2 ** k):
t = bin(m).count('1')
transformed_val = (x + t) % 3
transformed.append('abc'[transformed_val])
result.append(''.join(transformed))
return ''.join(result)
1，复杂度分析
-
时间复杂度：O(n * 2^k)
- 每个字符需要生成 2^k 个字符
-
空间复杂度：O(n * 2^k)
- 存储最终的字符串
2，边界测试
if __name__ == '__main__':
# 常规测试
print(solution("abc", 2) == 'caababbcbcca')
print(solution("abca", 3) == 'abbcbccabccacaabcaababbcabbcbcca')
print(solution("cba", 1) == 'abcabc')
# 边界测试：k=0
print(solution("abc", 0) == "abc")
# 边界测试：空字符串
print(solution("", 2) == "")
四，总结
通过数学规律和组合生成，我们实现了：
- 高效生成变换后的字符串：避免逐次模拟，直接计算最终结果
- 清晰的逻辑：基于字符数值和组合规律
- 普适性：适用于所有由 "abc" 组成的字符串和任意 k 值
这种解法不仅高效，还易于理解和实现。当遇到“需要多次变换字符串”类问题时，寻找数学规律和组合模式往往是解决问题的关键策略。
