深圳做网站推广的公司软文推广

1.字符串转换后的长度 I

1.1题目

3335. 字符串转换后的长度 I - 力扣（LeetCode）

1.2解析

递推法解析

思路框架

我们可以通过定义状态变量来追踪每次转换后各字符的数量变化。具体地，定义状态函数 f(i,c) 表示经过 i 次转换后，字符 c（对应 ASCII 码偏移量，如 a=0,b=1,…,z=25）在字符串中的出现次数。通过分析字符转换规则，我们可以建立递推关系，从而高效计算最终结果。

状态转移分析

1. 初始状态：

   • 对于给定字符串 s，初始化 f(0,c) 为字符 c 在 s 中的出现次数。

2. 状态转移方程：

   • 字符 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)

3. 优化空间复杂度：

   • 由于每次递推仅依赖前一层的状态，我们可以使用两个一维数组（如 cnt 和 nxt）交替存储状态，将空间复杂度从 O(t×26) 优化至 O(26)。

算法实现步骤

1. 初始化：统计字符串 s 中每个字符的出现次数，存入数组 cnt。
2. 迭代递推：
   • 执行 t 次状态转移，每次生成新数组 nxt 存储当前层状态。
   • 根据上述转移方程更新 nxt 数组。
   • 将 nxt 赋值给 cnt，为下一次迭代做准备。
3. 结果计算：累加最终状态数组 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 。这样就避免了像普通方法那样进行多次连乘，大幅减少了计算量。

计算过程

1. 把幂次 n 转换为二进制数。
2. 初始化结果变量为 1 ，底数为 a 。
3. 从二进制数的最高位开始遍历：
   • 如果当前位是 1 ，就把当前的结果乘以对应的幂次（比如从最高位开始，第一位对应 最高位序号 ）。
   • 每次遍历完一位，都将底数进行平方操作，为下一位的计算做准备。
4. 遍历完二进制数的所有位后，得到的结果就是 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矩阵快速幂

而本题则要用到矩阵快速幂

方法一：动态规划（基础解法）

思路分析

我们可以通过动态规划的方式，逐步计算每个字母在经过多次替换后的长度。具体来说：

1. 子问题定义：对于每个字母（如 'a', 'b', ..., 'z'），将其替换 t 次后的长度可以分解为替换 t-1 次后的子问题。例如，字母 'a' 替换一次后变为 'b' 和 'c'，因此其替换 t 次后的长度等于 'b' 和 'c' 分别替换 t-1 次后的长度之和。

2. 状态定义：定义 f[i][j] 表示字母 j（0 对应 'a'，1 对应 'b'，依此类推）替换 i 次后的长度。

3. 状态转移方程：对于每个字母 j，设 c = nums[j]，则有： 

4. 即字母 j 替换 i 次后的长度等于其替换一次后生成的所有字母（共 c 个）在替换 i-1 次后的长度之和。

5. 初始条件：当 i=0 时，即未进行任何替换，每个字母的长度为 1，因此： f[0][j] = 1

6. 最终结果：遍历字符串 s，统计每个字母的出现次数 cnt[j]，最终结果为所有字母替换 t 次后的长度之和：

这种方法适用于替换次数 t 较小的情况，但对于较大的 t 会导致超时，需要进一步优化。

方法二：矩阵快速幂优化

思路分析

当替换次数 t 非常大时，动态规划的时间复杂度会变得很高。此时，可以利用矩阵快速幂来优化计算过程。

1. 矩阵表示：将状态转移方程转化为矩阵乘法形式。对于每个字母 j，其替换后的长度可以表示为矩阵乘法的结果。例如，在示例中，状态转移可以表示为：

2. F[i] = M * F[i-1]，其中 M 是转移矩阵。

3. 递推关系：通过递推可得：
   F[t] = M^t * F[0]

4. 结果计算：由于 F[0] 全为 1，因此 f[t][j] 等于矩阵 M^t的第 j 行所有元素之和。最终结果为：

5. 这种方法通过矩阵快速幂将时间复杂度从指数级优化到对数级，能够高效处理大规模的替换次数。

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;}
};

本题解是在学习力扣题解基础上总结而来，感谢大家观看！