1.字符串转换后的长度 I
1.1题目
3335. 字符串转换后的长度 I - 力扣（LeetCode）
1.2解析
递推法解析
思路框架
我们可以通过定义状态变量来追踪每次转换后各字符的数量变化。具体地，定义状态函数 f(i,c) 表示经过 i 次转换后，字符 c（对应 ASCII 码偏移量，如 a=0,b=1,…,z=25）在字符串中的出现次数。通过分析字符转换规则，我们可以建立递推关系，从而高效计算最终结果。
状态转移分析
-
初始状态：
- 对于给定字符串 s，初始化 f(0,c) 为字符 c 在 s 中的出现次数。
-
状态转移方程：
- 字符 a（对应 c=0）：只能由前一次的字符 z 转换而来，因此：
f(i,0)=f(i−1,25) - 字符 b（对应 c=1）：可由前一次的字符 z 或 a 转换而来，因此：
f(i,1)=f(i−1,25)+f(i−1,0) - 其他字符 c≥2：由前一次的字符 c−1 转换而来，因此：
f(i,c)=f(i−1,c−1)
- 字符 a（对应 c=0）：只能由前一次的字符 z 转换而来，因此：
-
优化空间复杂度：
- 由于每次递推仅依赖前一层的状态，我们可以使用两个一维数组（如
cnt和nxt）交替存储状态，将空间复杂度从 O(t×26) 优化至 O(26)。
- 由于每次递推仅依赖前一层的状态，我们可以使用两个一维数组（如
算法实现步骤
- 初始化：统计字符串 s 中每个字符的出现次数，存入数组
cnt。 - 迭代递推：
- 执行 t 次状态转移，每次生成新数组
nxt存储当前层状态。 - 根据上述转移方程更新
nxt数组。 - 将
nxt赋值给cnt，为下一次迭代做准备。
- 执行 t 次状态转移，每次生成新数组
- 结果计算：累加最终状态数组
cnt中所有元素的和，即为转换 t 次后的字符串长度。
复杂度分析
- 时间复杂度：O(n+t)，其中 n 是字符串 s 的长度，t 是转换次数。初始化需遍历一次字符串，每次转换需处理 26 个字符。
- 空间复杂度：O(1)，仅需固定大小的数组存储状态，与输入规模无关。
1.3代码
class Solution {
public:
int lengthAfterTransformations(string s, int t) {
vector<int> cnt(26);
for(auto ch:s)
{
++cnt[ch-'a'];
}
for(int i=0;i<t;i++)
{
vector<int> next(26);
next[0]=cnt[25];
next[1]=(cnt[25]+cnt[0])%(1000000007);
for(int i=2;i<26;i++)
{
next[i]=cnt[i-1];
}
cnt=move(next);
}
int ans=0;
for(int i=0;i<26;i++)
{
ans=(ans+cnt[i])%(1000000007);
}
return ans;
}
};2.3337字符串转换后的长度 ||
2.1原题
3337. 字符串转换后的长度 II - 力扣（LeetCode）
2.2快速幂模板
首先我们先学一下快速幂
快速幂是一种高效计算幂运算的方法 。
原理
- 二进制角度：将幂次 n 转化为二进制形式。例如幂次 13，其十进制数 13 转换为二进制是 1101 ，而 11012=2^3+2^2+2^0=8+4+1 。这就把幂次的计算拆解成了与二进制位相关的形式。
- 幂的性质利用：依据幂的性质 a2k=(ak)2 来进行计算。从 a 开始，通过不断平方得到 a,a2,a4,a8,⋯ 这些值。比如计算 a13 ，因为 13 二进制表示中第 0 位、第 2 位、第 3 位是 1 ，对应着 a1 、 a4 、 a8 ，所以 a13=a8×a4×a1 。这样就避免了像普通方法那样进行多次连乘，大幅减少了计算量。
计算过程
- 把幂次 n 转换为二进制数。
- 初始化结果变量为 1 ，底数为 a 。
- 从二进制数的最高位开始遍历：
- 如果当前位是 1 ，就把当前的结果乘以对应的幂次（比如从最高位开始，第一位对应 最高位序号 ）。
- 每次遍历完一位，都将底数进行平方操作，为下一位的计算做准备。
- 遍历完二进制数的所有位后，得到的结果就是 an 。
优势
传统计算 an ，需要进行 n−1 次乘法，时间复杂度是 O(n) 。而快速幂通过上述方式，时间复杂度降为 O(logn) 。当 n 很大时，计算效率会有显著提升。
快速幂模板代码
#define ll long long
#define mod ......
ll qsm(ll a,ll b)
{
ll res=0;
while(b)
{
if(b&1)res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res;
}2.3矩阵快速幂
而本题则要用到矩阵快速幂
方法一：动态规划（基础解法）
思路分析
我们可以通过动态规划的方式，逐步计算每个字母在经过多次替换后的长度。具体来说：
-
子问题定义：对于每个字母（如 'a', 'b', ..., 'z'），将其替换
t次后的长度可以分解为替换t-1次后的子问题。例如，字母 'a' 替换一次后变为 'b' 和 'c'，因此其替换t次后的长度等于 'b' 和 'c' 分别替换t-1次后的长度之和。 -
状态定义：定义
f[i][j]表示字母j（0 对应 'a'，1 对应 'b'，依此类推）替换i次后的长度。 -
状态转移方程：对于每个字母
j，设c = nums[j]，则有：
-
即字母
j替换i次后的长度等于其替换一次后生成的所有字母（共c个）在替换i-1次后的长度之和。 -
初始条件：当
i=0时，即未进行任何替换，每个字母的长度为 1，因此： f[0][j] = 1 -
最终结果：遍历字符串
s，统计每个字母的出现次数cnt[j]，最终结果为所有字母替换t次后的长度之和：
这种方法适用于替换次数 t 较小的情况，但对于较大的 t 会导致超时，需要进一步优化。
方法二：矩阵快速幂优化
思路分析
当替换次数 t 非常大时，动态规划的时间复杂度会变得很高。此时，可以利用矩阵快速幂来优化计算过程。
-
矩阵表示：将状态转移方程转化为矩阵乘法形式。对于每个字母
j，其替换后的长度可以表示为矩阵乘法的结果。例如，在示例中，状态转移可以表示为： -
F[i] = M * F[i-1]，其中 M 是转移矩阵。
-
递推关系：通过递推可得：
F[t] = M^t * F[0] -
结果计算：由于 F[0] 全为 1，因此 f[t][j] 等于矩阵 M^t的第 j 行所有元素之和。最终结果为：
-
这种方法通过矩阵快速幂将时间复杂度从指数级优化到对数级，能够高效处理大规模的替换次数。
2.4题解代码
class Solution {
public:
const int MOD=1000000007;
using Matrix = array<array<int,26>,26>;
Matrix mul(Matrix &a,Matrix &b)//矩阵乘法
{
Matrix c{};
for(int i=0;i<26;i++)
{
for(int k=0;k<26;k++)
{
if(a[i][k]==0)continue;//如果是0可以直接跳过
for(int j=0;j<26;j++)
{
c[i][j]=(c[i][j]+(long long) a[i][k]*b[k][j])%MOD;
}
}
}
return c;
}
Matrix pow(Matrix a,int n)//矩阵快速幂
{
Matrix res={};
for(int i=0;i<26;i++)
{
res[i][i]=1;
}
while(n)
{
if(n&1)
{
res=mul(res,a);
}
a=mul(a,a);
n>>=1;
}
return res;
}
int lengthAfterTransformations(string s, int t, vector<int>& nums) {
Matrix m{};
for(int i=0;i<26;i++)
{
for(int j=i+1;j<=i+nums[i];j++)
{
m[i][j%26]=1;
}
}
Matrix mt=pow(m,t);
int cnt[26]{};
for(char c:s)
{
cnt[c-'a']++;
}
long long ans=0;
for(int i=0;i<26;i++)
{
ans += reduce(mt[i].begin(), mt[i].end(), 0LL) * cnt[i];
}
return ans%MOD;
}
};本题解是在学习力扣题解基础上总结而来，感谢大家观看！
