模拟算法思想就是依葫芦画瓢，题目已经给出了具体的解法步骤，我们需要将过程转化成代码。这类题的思路比较简单，但是考验我们的代码能力。一定要模拟算法流程（打草稿），不然都不知道怎么调试错误信息。
算法题目
题目1：1576. 替换所有的问号 - 力扣（LeetCode）
题目分析
给你一个仅包含小写英文字母和
'?'字符的字符串s，请你将所有的'?'转换为若干小写字母，使最终的字符串不包含任何 连续重复 的字符。注意：你 不能 修改非
'?'字符。题目测试用例保证 除
'?'字符 之外，不存在连续重复的字符。在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。可以证明，在给定的约束条件下，答案总是存在的。
题目示例
示例 1：
输入：s = "?zs" 输出："azs" 解释：该示例共有 25 种解决方案，从 "azs" 到 "yzs" 都是符合题目要求的。只有 "z" 是无效的修改，因为字符串 "zzs" 中有连续重复的两个 'z' 。示例 2：
输入：s = "ubv?w" 输出："ubvaw" 解释：该示例共有 24 种解决方案，只有替换成 "v" 和 "w" 不符合题目要求。因为 "ubvvw" 和 "ubvww" 都包含连续重复的字符。
算法原理
遍历字符串，遍历到'?'，从 a~z 选取字母，判断是否等于?前一个字符或者后一个字符。
细节处理：如果'?'在最前或最右，它是没有前一个字符和后一个字符的，这种情况下，仅需判断后一个字符和前一个字符即可。
代码实现
cpp
class Solution {
public:
string modifyString(string s) {
// 遍历
for(int i = 0; i < s.length(); i++)
{
if(s[i] == '?')
{
for(char c = 'a'; c <= 'z'; c++)
{
// 如果?在最左或最右，仅需比较后一个字符和前一个字符即可
if(i == 0 || i == s.length() - 1)
{
if(i == 0 && s[i + 1] != c) { s[i] = c; break; }
if(i == s.length() - 1 && s[i - 1] != c) { s[i] = c; break; }
}
// 如果?不在最左或最右，需要比较前后两个字符
else
{
if(s[i - 1] != c && s[i + 1] != c) { s[i] = c; break; }
}
}
}
}
return s;
}
};优化
cpp
class Solution {
public:
string modifyString(string s) {
// 遍历
for(int i = 0; i < s.length(); i++)
{
// 替换
if(s[i] == '?')
{
for(char c = 'a'; c <= 'z'; c++)
{
// 如果?在最左或最右，仅需比较后一个字符和前一个字符即可
if((i == 0 || s[i - 1] != c) && ((i == s.length() - 1) || s[i + 1] != c))
{
s[i] = c;
break;
}
}
}
}
return s;
}
};题目2：495. 提莫攻击 - 力扣（LeetCode）
题目分析
在《英雄联盟》的世界中，有一个叫 "提莫" 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。
当提莫攻击艾希，艾希的中毒状态正好持续
duration秒。正式地讲，提莫在
t发起攻击意味着艾希在时间区间[t, t + duration - 1]（含t和t + duration - 1）处于中毒状态。如果提莫在中毒影响结束 前 再次攻击，中毒状态计时器将会 重置 ，在新的攻击之后，中毒影响将会在duration秒后结束。给你一个 非递减 的整数数组
timeSeries，其中timeSeries[i]表示提莫在timeSeries[i]秒时对艾希发起攻击，以及一个表示中毒持续时间的整数duration。返回艾希处于中毒状态的 总 秒数。
题目示例
示例 1：
输入：timeSeries = [1,4], duration = 2 输出：4 解释：提莫攻击对艾希的影响如下： - 第 1 秒，提莫攻击艾希并使其立即中毒。中毒状态会维持 2 秒，即第 1 秒和第 2 秒。 - 第 4 秒，提莫再次攻击艾希，艾希中毒状态又持续 2 秒，即第 4 秒和第 5 秒。 艾希在第 1、2、4、5 秒处于中毒状态，所以总中毒秒数是 4 。示例 2：
输入：timeSeries = [1,2], duration = 2 输出：3 解释：提莫攻击对艾希的影响如下： - 第 1 秒，提莫攻击艾希并使其立即中毒。中毒状态会维持 2 秒，即第 1 秒和第 2 秒。 - 第 2 秒，提莫再次攻击艾希，并重置中毒计时器，艾希中毒状态需要持续 2 秒，即第 2 秒和第 3 秒。 艾希在第 1、2、3 秒处于中毒状态，所以总中毒秒数是 3
示例分析
模拟流程
算法原理
设攻击时间为 a,b 秒，中毒时长 d 秒。
由于题目涉及中毒时间重置的情况，因此需要计算前后两次攻击的时间差 b-a，如果 b-a>=d，那么需要累加 a 攻击后中毒的时长+ b攻击后中毒的时长；如果 b-a<d，a 攻击后中毒的时长不能吃满，再次从 b 攻击开始计算中毒时长，因此总时长为 b-a+d。
例：timeSeries = [1,4,5,6,12,19], duration = 3
代码实现
cpp
class Solution {
public:
int findPoisonedDuration(vector<int>& timeSeries, int duration) {
// 返回值
int ret = 0;
// 遍历,从下标1开始
for(int i = 1; i < timeSeries.size(); i++)
{
if(timeSeries[i] - timeSeries[i - 1] > duration) { ret += duration; }
else { ret += (timeSeries[i] - timeSeries[i - 1]); }
}
// 记得加上最后一次攻击时的中毒时长
ret += duration;
return ret;
}
};题目3：6. Z 字形变换 - 力扣（LeetCode）
题目分析
将一个给定字符串
s根据给定的行数numRows，以从上往下、从左到右进行 Z 字形排列。比如输入字符串为
"PAYPALISHIRING"行数为3时，排列如下：
P A H N A P L S I I G Y I R之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：
"PAHNAPLSIIGYIR"。请你实现这个将字符串进行指定行数变换的函数：
string convert(string s, int numRows);
题目示例
示例 1：
输入：s = "PAYPALISHIRING", numRows = 3 输出："PAHNAPLSIIGYIR"示例 2：
输入：s = "PAYPALISHIRING", numRows = 4 输出："PINALSIGYAHRPI" 解释： P I N A L S I G Y A H R P I示例 3：
输入：s = "A", numRows = 1 输出："A"
示例分析
例：numRows = "abcdefghijklm"，n = 4。
算法原理
解法1：模拟
如果想使用模拟来解决该题，首先需要获取到字符串 s 的 Z字形排列，因此需要创建一个矩阵。矩阵多大？4行s.length列。怎么填？先填充第0列，第0列填充完毕之后，在斜向上填充，i-1，j+1，直到填到第0行，接着重复相同的操作。填充完毕之后，再遍历矩阵，得到的就是返回值。如果使用上述的操作来解决这道题，时间复杂度和空间复杂度都是特别高的。编写出的代码是可以通过的。
解法2：找规律 + 模拟
我们细心的观察是可以发现存在规律的。
一行一行的观察，第一行与最后一行的规律是一样的，第一行从0开始，跳跃间隔为6，最后一行是从n-1开始，跳跃间隔为6，跳跃间隔也就是公差，设为 d。公差 d 就是两个字符之间的元素个数，0和6之间存在6个元素(0~5)，怎么计算出来的？将 5 向前平移，那么元素个数等于第一列和第二列的元素和减去空着的个数，即d = 2n -- 2。因此第1行的规律为：0+kd ，最后一行的规律为：(n-1) + kd。
接下来观察中间几行的规律。第二行和第三行的公差也是d，只不过在递进的过程中多了几个数，并且注意到1+5，7+11正好等于公差的倍数。因此第m行的规律是：(m, d-m)+kd。
接下来再验证 n 为其它数的情况下是否适用，如 n = 3。
需要特殊处理 n=1 的情况，当n=1时，d计算出来的是0，这样会陷入死循环。
代码实现
cpp
class Solution {
public:
string convert(string s, int numRows) {
// 特殊处理,numRows等于0
if(numRows == 1) { return s; }
// 返回值
string ret;
// 计算公差 d
int d = 2 * (numRows - 1);
// 字符串的长度
int len = s.length();
// 处理第一行
for(int i = 0; i < len; i += d) { ret += s[i]; }
// 处理中间行
for(int m = 1; m < numRows - 1; m++)
{
// 另一个
for(int j = m, k = d - m; j < len || k < len; j += d, k += d)
{
// 先填充j,再填充k
// 判断j是否越界
if(j < len) { ret += s[j]; }
// 判断k是否越界
if(k < len) { ret += s[k]; }
}
}
// 处理最后一行
for(int i = numRows - 1; i < len; i += d) { ret += s[i]; }
return ret;
}
};题目4：38. 外观数列 - 力扣（LeetCode）
题目分析
「外观数列」是一个数位字符串序列，由递归公式定义：
countAndSay(1) = "1"countAndSay(n)是countAndSay(n-1)的行程长度编码。行程长度编码（RLE）是一种字符串压缩方法，其工作原理是通过将连续相同字符（重复两次或更多次）替换为字符重复次数（运行长度）和字符的串联。例如，要压缩字符串
"3322251"，我们将"33"用"23"替换，将"222"用"32"替换，将"5"用"15"替换并将"1"用"11"替换。因此压缩后字符串变为"23321511"。给定一个整数
n，返回 外观数列 的第n个元素。
题目示例
示例 1：
**输入：**n = 4
输出："1211"
解释：
countAndSay(1) = "1"
countAndSay(2) = "1" 的行程长度编码 = "11"
countAndSay(3) = "11" 的行程长度编码 = "21"
countAndSay(4) = "21" 的行程长度编码 = "1211"
示例 2：
**输入：**n = 1
输出："1"
解释：
这是基本情况。
示例分析
算法原理
解法：模拟 + 双指针
定义两个指针 left 和 right，获取字符串中元素相同的子串。
代码实现
cpp
class Solution {
public:
string countAndSay(int n) {
// 返回值,至少要有1
string ret = "1";
// 从 1 开始解释，仅需解释 n-1 次
for(int i = 1; i < n; i++)
{
// 记录本次翻译的结果
string tmp;
// 双指针
for(int left = 0, right = 0; right <= ret.length(); right++)
{
// 如果right指向的元素不等于left指向的元素
// 说明此时 [left,right] 区间全是相同的元素
if(ret[right] != ret[left])
{
// 相同元素的个数
int count = right - left;
// 转换成字符型,也可以使用to_string函数
// 加上相同的元素
tmp += to_string(right - left) + ret[left];
// to_string函数不了解,可以使用另一种方法
//tmp += count + '0';
//tmp += ret[left];
// 继续向后移动确定相同元素的区间
left = right;
}
}
// 交给返回值
ret = tmp;
}
return ret;
}
};题目5：1419. 数青蛙 - 力扣（LeetCode）
题目分析
给你一个字符串
croakOfFrogs，它表示不同青蛙发出的蛙鸣声（字符串"croak"）的组合。由于同一时间可以有多只青蛙呱呱作响，所以croakOfFrogs中会混合多个"croak"。请你返回模拟字符串中所有蛙鸣所需不同青蛙的最少数目。
要想发出蛙鸣 "croak"，青蛙必须 依序 输出
'c', 'r', 'o', 'a', 'k'这 5 个字母。如果没有输出全部五个字母，那么它就不会发出声音。如果字符串croakOfFrogs不是由若干有效的 "croak" 字符混合而成，请返回-1。
题目示例
示例 1：
输入：croakOfFrogs = "croakcroak" 输出：1 解释：一只青蛙 “呱呱” 两次示例 2：
输入：croakOfFrogs = "crcoakroak" 输出：2 解释：最少需要两只青蛙，“呱呱” 声用黑体标注 第一只青蛙 "crcoakroak" 第二只青蛙 "crcoakroak"示例 3：
输入：croakOfFrogs = "croakcrook" 输出：-1 解释：给出的字符串不是 "croak" 的有效组合。
提示：
1 <= croakOfFrogs.length <= 105- 字符串中的字符只有
'c','r','o','a'或者'k'
示例1的输出说明了一种情况当一只青蛙"croak"全部叫完之后，可以再次叫。在这只青蛙正在叫时，另一只青蛙也可以叫，但是必须要将"croak"全部叫完才算一只青蛙的叫声。
算法原理
例：crcoakroakcroak。
当遍历到r时，仅需判断前面青蛙是否叫了'c'。
当遍历到o时，仅需判断前面青蛙是否叫了'r'。
我们需要知道遍历到某处，前面字符出现的次数，因此需要 hash 表。
具体思路：
遍历到 r,o,a,k 时，判断前去字符是否存在 hash 表中。若存在，则前驱字符个数--，当前字符个数++；若不存在，则直接返回-1
遍历到 c 时，找最后一个字符 'k' 是否存在 hash 表。若存在，最后一个字符个数--，当前字符个数++；若不存在，当前字符个数++
遍历完毕后，看 hash 表中除k的个数不为0之外，若存在某个字符不为0，直接返回-1。若不存在返回 hash 表中 k 的个数
示例：crcoakroakcroak。
代码实现
多层 if 判断
cpp
class Solution {
public:
int minNumberOfFrogs(string croakOfFrogs) {
// 创建hash表
unordered_map<char, int> hash;
for(auto e : croakOfFrogs)
{
if(e == 'c')
{
// 前驱字符字符
if(hash['k']) { hash['k']--; }
hash[e]++;
}
else if(e == 'r')
{
if(hash['c']) { hash['c']--; hash[e]++; }
else { return -1; }
}
else if(e == 'o')
{
if(hash['r']) { hash['r']--; hash[e]++; }
else { return -1; }
}
else if(e == 'a')
{
if(hash['o']) { hash['o']--; hash[e]++; }
else { return -1; }
}
else if(e == 'k')
{
if(hash['a']) { hash['a']--; hash[e]++; }
else { return -1; }
}
}
for(auto& kv : hash)
{
if(kv.first != 'k' && kv.second != 0) { return -1; }
}
return hash['k'];
}
};hash 映射
cpp
class Solution {
public:
int minNumberOfFrogs(string croakOfFrogs) {
// 指出蛙鸣"croak"
string s = "croak";
// 蛙鸣的长度
int n = s.length();
// 使用数组模拟hash表
vector<int> hash(n);
// 存储"croak"中字符的下标，使用hash表存储
// 存储x字符以及x字符对应的下标
unordered_map<char, int> index;
// 遍历蛙鸣字符串
for(int i = 0; i < n; i++)
{
index[s[i]] = i;
}
// 遍历croakOfFrogs字符串
for(auto ch : croakOfFrogs)
{
if(ch == 'c')
{
// 找'k'
// 若 'k' 存在hash数组中，前驱字符--，当前字符++
if(hash[n - 1] != 0) { hash[n - 1]--; }
// 若 'k' 不存在hash数组中，当前字符++
hash[0]++;
}
else
{
// 当前字符的下标
int i = index[ch];
// 判断当前字符下标的前驱字符是否存在hash数组中
// 不存在直接返回-1
if(hash[i - 1] == 0) { return -1; }
// 存在，前驱字符--，当前字符++
hash[i - 1]--;
hash[i]++;
}
}
// 除了最后一个字符'k'之外，其它字符的个数为0
for(int i = 0; i < n - 1; i++)
{
// 若不为0,直接返回-1
if(hash[i] != 0) { return -1; }
}
// 返回hash数组中最后一个元素'k'对应的个数
return hash[n - 1];
}
};