算法学习（六） —— 模拟运算

原创已于 2026-02-09 18:58:45 修改 · 1.1k 阅读

19 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

算法集合

于 2024-10-28 15:14:23 首次发布

关于模拟

模拟算法，通俗来讲就是“比葫芦画瓢”，特点就是：“思路比较简单”，直接根据题目要求来

这个算法考察的就是我们的代码能力

步骤：

模拟算法过程（一定要在演草纸上过一遍流程）
把流程转化为代码

OJ题详解

1576. 替换所有的问号

1576. 替换所有的问号 - 力扣（LeetCode）

解释下题目：就是把一个字符串的所有‘ ？’替换成其它小写字母，并且保证最终字符串没有连续重复的字母，下面来分析下这道题：

就是找到‘ ？’，然后替换成“a ~ z”的任何一个字母，并且保证与其前面并且与其后面的字母不重复即可
细节：当‘ ？’在字符串首位或者末位时，只需要保证其与前面或者后面的字母不相同即可

class Solution {
public:
    string modifyString(string s) {
        int n = s.size();
        for(int i = 0; i< n; i++)
        {
            if(s[i] == '?')
            {
                for(char ch = 'a'; ch <= 'z'; ch++)
                {
                    if((i == 0 || ch != s[i - 1]) && (i == n - 1) || ch != s[i + 1]) //四个条件
                    {
                        s[i] = ch;
                        break;
                    }
                }
            }
        }
        return s;
    }
};

495. 提莫攻击

495. 提莫攻击 - 力扣（LeetCode）

这个题目打游戏的小伙伴应该很快就能理解题目啥意思，不打游戏的小伙伴也没关系，题目读完后也会理解的，下面来分析下这道题：

假设在a秒和b秒时发动攻击，那么我们只需要看两个秒的差值即可：x = b - a
当x >= d（d为中毒时间），说明在a的时间要全部加上 ret += d；当x < d时，时间要被重置 ret += x

class Solution {
public:
    int findPoisonedDuration(vector<int>& timeSeries, int duration) 
    {
        int ret = 0;
        for(int i = 1; i < timeSeries.size(); i++)
        {
            int x = timeSeries[i] - timeSeries[i - 1];
            if(x >= duration)
            {
                ret += duration;
            }
            else
            {
                ret += x;
            }
        }
        ret += duration; //最后一秒加中毒debuff时，要再加一段中毒时间
        return ret;
    }
};

6. Z 字形变换

6. Z 字形变换 - 力扣（LeetCode）

解释下题目：题目给的字符串太恶心了，我们用一个简单的字符来代替：abcdefghijklm，n = 4

题目的意思就是。。。直接看图片吧（摊手）：

下面来分析下这道题：

解法一：根据题目要求模拟一下题目即可，首先我们要搞一个矩阵，行数要和n一样，列数可以根据周期性来计算，但是这个太麻烦，所以我们可以直接简单粗暴一点，有多少个字符我们就搞多少列的矩阵，因为不排除n = 1的情况
但是空间复杂度和时间复杂度都是O(len × n)，这个时间复杂度有点高，所以我们要想办法优化一下上面的模拟，99%的模拟算法的优化，都是“找规律”。
解法二：找规律

class Solution {
public:
    string convert(string s, int numRows) 
    {
        if(numRows == 1) return s;

        string ret;
        int d = 2 * numRows - 2; //计算公差
        int n = s.size();
        //1，先计算第一行
        for(int i = 0; i < n; i += d)
            ret += s[i];

        //2，处理中间行
        for(int k  = 1; k < numRows - 1; k++) //枚举中间每一行
        {
            //两个位置依次往后递进
            for(int i = k, j = d - k; i < n || j < n; i += d, j += d)
            {
                //先添加i再添加j，但是由于i和j的越界顺序不定，所以先判断一下
                if(i < n) ret += s[i];
                if(j < n) ret += s[j];
            }
        }

        //3，处理最后一行
        for(int i = numRows - 1; i < n; i += d)
            ret += s[i];

            return ret;
    }
};

38，外观数列

38. 外观数列 - 力扣（LeetCode）

解释下题目：假设第一项就是1，那么第二项就念作：“1个1”，所以第二项就是11；第三项是对第二项的集合，由于第二项是11，那么第三项就念作：“2个1”，所以第三项就是21；第四项同理，所以第四项就念作：“1个2，1个1”，所以第四项就是1211，往后都是如此，第五项就是“1个1，1个2，2个1”，就是111221，第六项就是312211

下面我们来分析下题目：

解法：模拟。现在我们需要解决的，就是如何去“解释”一个字符串；假设我们要“解释”的字符串是 3 3 3 4 1 1 1 1 5 5 4，我们直接用双指针来搞
刚开始right和left全部指向起始位置，right先走，找连续3这个区域的边界，如果right == left，right++，当不相同时，记录right - left，填充ret
然后right不懂，left移到right，然后right再动，重复上面的步骤，当right == s.size()时，停止遍历

class Solution {
public:
    string countAndSay(int n) 
    {
        string ret = "1";
        for(int i = 1; i < n; i++)
        {
            string tmp;
            int len = ret.size();
            for(int left = 0, right = 0; right < len;)
            {
                while(right < len && ret[left] == ret[right])
                {
                    right++;
                }
                tmp += to_string(right - left) + ret[left];
                left = right;
            }
            ret = tmp;
        }
        return ret;
    }
};

1419. 数青蛙

1419. 数青蛙 - 力扣（LeetCode）

解释下题目：一个青蛙叫一次就是要把croak五个字母全叫了一遍，如果没有输出五个字母，那么就不会发出声音，如示例1和示例2和示例三，下面来分析下这道题：

解法：模拟，能够用青蛙模拟出给定字符串的叫法即可，但是这道题的模拟策略不太好搞
一次正常的蛙叫是“c r o a k”首先我们从左往右遍历，当遍历到 r 时，只要判断前面有没有 c 这个字符出现，遍历到 o 的时候，只需要判断前面有没有 c 和 r 出现即可，所以我们需要一个哈希表来统计前面字符的出现情况
以c r c o a k r o a k c r o a k例，以c为起点，先把c扔哈希表里去，接着把r扔进去，当r进到哈希表里之后，先看前面有没有c，然后我们前面正好有一个c，于是把r的value置1，把c的value置0
然后我们再次遇到了c，把c扔进去，说明又有一个青蛙过来了，然后遍历到o，先去看前面有没有r，诶，刚好有个r，把r置0，把o置1，然后遍历a和k的时候都是同样的步骤
遍历到第二个r的时候，往前面找c，然后第二个c次数正在里面躺着呢，然后和上面的步骤一样搞，最终遍历到第二个k时，k为2，其余都为0，表示两个青蛙已经叫完了
细节：遍历第三个c时，说明又有青蛙开始叫了，但是题目要求的是最小的青蛙数，所以当再次遍历c时，先看k是否为0：①如果为0，说明来了一只新青蛙开始叫了； ②如果为1，说明之前叫完的青蛙再次开始叫了，所以把k--再重新上面的步骤
当把字符串遍历完后，正常结果应该是：哈希表中k不为0，其余字母全为0，如果有一个除k以外的字母不为0，则返回-1
在遍历途中，如果遍历到一个字母，发现前面的字母为0，以 c r r o a k为例，当遍历到第二个r时，往前面找c，但是前面没有c，所以返回-1
总结：r，o，a，k这四个字母的逻辑是一样的，遍历到这四个字母时，找一下前驱字符是否在哈希表中，①如果存在，前驱字母个数--，当前字符++； ②如果不存在，直接返回-1
当遍历到c时，找k是否在哈希表中：①如果在，k--，c++； ②如果不存在，当前字符++

class Solution {
public:
    int minNumberOfFrogs(string str) 
    {
        string t = "croak";
        int n = t.size();
        int hash[5] = { 0 }; //用数组模拟哈希表

        unordered_map<char, int> map; //存的就是[x, x这个字符对应的下标]，下标-1之后就是前驱字符
        for(int i = 0;i < n; i++) //把蛙叫的五个字母的下标搞进去
            map[t[i]] = i; 

        for(auto ch : str)
        {
            if(ch == 'c')
            {
                if(hash[n - 1] != 0) //如果遍历c时，k不为0，表示前面有青蛙叫完了，这个青蛙准备第二次叫
                    hash[n - 1]--;
                hash[0]++;
            }
            else
            {
                int i = map[ch]; //找到除c之外四个字符的某一个字符的下标，从而找到这个字符
                if(hash[i - 1] == 0) //找前驱字符，如果前驱字符为0，直接返回-1
                {
                    return -1;
                }
                else //前驱存在，前驱--，当前字符++
                {
                    hash[i - 1]--;
                    hash[i]++;
                }
            }
        }
        //走到这里说明给定的字符已经遍历完毕，接下来要做的就是遍历hash，正常情况是除k以外的字符都为0，如果有某个字符不为0，则返回-1
        for(int i = 0;i < n - 1; i++)
        {
            if(hash[i] != 0) return -1;
        }
        return hash[n - 1];
    }
};

标签

#1024程序员节