2025-05-24：字符串转换后的长度Ⅰ。用go语言，给定一个字符串 s 和一个整数 t，表示需要进行的转换次数。每次转换中，对字符串中每个字符进行如下替换规则：

• 若字符是 ‘z’，则用字符串 “ab” 替换它；

• 否则，将该字符替换为字母表中下一个字符（例如 ‘a’ 变成 ‘b’，‘b’ 变成 ‘c’，依次类推）。
  要求计算执行完第 t 次转换后，最终字符串的长度。由于结果可能非常大，需要返回结果对 1000000007 取模的值。

1 <= s.length <= 100000。

s 仅由小写英文字母组成。

1 <= t <= 100000。

输入： s = “abcyy”, t = 2。

输出： 7。

解释：

第一次转换 (t = 1)

‘a’ 变为 ‘b’

‘b’ 变为 ‘c’

‘c’ 变为 ‘d’

‘y’ 变为 ‘z’

‘y’ 变为 ‘z’

第一次转换后的字符串为：“bcdzz”

第二次转换 (t = 2)

‘b’ 变为 ‘c’

‘c’ 变为 ‘d’

‘d’ 变为 ‘e’

‘z’ 变为 “ab”

‘z’ 变为 “ab”

第二次转换后的字符串为：“cdeabab”

最终字符串长度：字符串为 “cdeabab”，长度为 7 个字符。

题目来自力扣3335。

算法流程：

1. 初始化 cnt[26]，统计 s 中每个字符的出现次数。
2. 预计算 pow2[t + 1]，其中 pow2[i] = 2^i % mod。
3. 初始化 ans = 0。
4. 对于每个字符 c（从 'a' 到 'z'）：
   • 如果 c == 'z'：
     • ans += cnt[25] * pow2[t] % mod。
   • 否则：
     • 计算 k = (25 - (c - 'a') + 26) % 26。
     • 如果 k <= t：
       • ans += cnt[c - 'a'] * pow2[t - k] % mod。
     • 否则：
       • ans += cnt[c - 'a'] % mod。
5. 返回 ans % mod。

时间复杂度和空间复杂度：

• 时间复杂度：
  • 统计字符频率：O(n)，其中 n 是 s 的长度。
  • 预计算 pow2：O(t)。
  • 计算每个字符的贡献：O(26)（因为只有 26 个字母）。
  • 总时间复杂度：O(n + t)。
• 空间复杂度：
  • cnt[26]：O(1)。
  • pow2[t + 1]：O(t)。
  • 总空间复杂度：O(t)。

Rust完整代码如下：

const MOD: usize = 1_000_000_007;

fn length_after_transformations(s: &str, t: usize) -> usize {
    let mut cnt = vec![0usize; 26];
    for ch in s.chars() {
        cnt[(ch as u8 - b'a') as usize] += 1;
    }
    for _ in 0..t {
        let mut nxt = vec![0usize; 26];
        // 'z' -> "ab"
        nxt[0] = cnt[25] % MOD;
        nxt[1] = (cnt[25] + cnt[0]) % MOD;
        for i in 2..26 {
            nxt[i] = cnt[i-1] % MOD;
        }
        cnt = nxt;
    }
    cnt.iter().fold(0, |acc, &x| (acc + x) % MOD)
}

fn main() {
    let s = "abcyy";
    let t = 2;
    let result = length_after_transformations(s, t);
    println!("{}", result);
}

Go完整代码如下：

package main

import (
	"fmt"
)

const mod = 1000000007

func lengthAfterTransformations(s string, t int) int {
	cnt := make([]int, 26)
	for _, ch := range s {
		cnt[ch-'a']++
	}
	for round := 0; round < t; round++ {
		nxt := make([]int, 26)
		nxt[0] = cnt[25]
		nxt[1] = (cnt[25] + cnt[0]) % mod
		for i := 2; i < 26; i++ {
			nxt[i] = cnt[i-1]
		}
		cnt = nxt
	}
	ans := 0
	for i := 0; i < 26; i++ {
		ans = (ans + cnt[i]) % mod
	}
	return ans
}

func main() {
	s := "abcyy"
	t := 2
	result := lengthAfterTransformations(s, t)
	fmt.Println(result)
}