一文详解“模拟算法“在算法中的应用

我要学编程(ಥ_ಥ)2024-11-20 9:59

找往期文章包括但不限于本期文章中不懂的知识点：

个人主页： 我要学编程(ಥ_ಥ)-CSDN博客

所属专栏： 优选算法专题

目录

介绍

1576.替换所有的问号

495.提莫攻击

6.Z字形变换

38.外观数列

[1419. 数青蛙](#1419. 数青蛙)

介绍

模拟算法的核心与其名一样，重在模拟，主要是根据题目的要求，进行无脑的暴力模拟去实现。这类题目还是比较简单的，相较于那些没有思路的题目来说。主要考察的是我们的编码能力。

1576.替换所有的问号

题目：

给你一个仅包含小写英文字母和 '?' 字符的字符串 s，请你将所有的 '?' 转换为若干小写字母，使最终的字符串不包含任何 连续重复 的字符。

注意：你 不能 修改非 '?' 字符。

题目测试用例保证 除 '?' 字符 之外，不存在连续重复的字符。

在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。可以证明，在给定的约束条件下，答案总是存在的。

示例 1：

复制代码 
输入：s = "?zs"
输出："azs"
解释：该示例共有 25 种解决方案，从 "azs" 到 "yzs" 都是符合题目要求的。只有 "z" 是无效的修改，因为字符串 "zzs" 中有连续重复的两个 'z' 。

示例 2：

复制代码 
输入：s = "ubv?w"
输出："ubvaw"
解释：该示例共有 24 种解决方案，只有替换成 "v" 和 "w" 不符合题目要求。因为 "ubvvw" 和 "ubvww" 都包含连续重复的字符。

提示：

  • 1 <= s.length <= 100

  • s 仅包含小写英文字母和 '?' 字符

思路：题目是让我们在一堆小写字母和"?"中，将"?"给替换成小写字母，且相邻的小写字母之间不能出现重复，但是不相邻的小写字母之间可以出现重复。

代码实现：

java 复制代码 
class Solution {
    public String modifyString(String s) {
        int n = s.length();
        if (n == 1) { // 排除特殊情况
            char ch = s.charAt(0);
            return ch == '?' ? "a" : s;
        }
        StringBuilder sb = new StringBuilder();
        char[] ans = s.toCharArray();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            if (ch == '?') {
                if (i == 0) { // 没有前缀字符
                    // 拿到后缀字符
                    char r = s.charAt(1);
                    for (char j = 'a'; j <= 'z'; j++) {
                        if (j != r) {
                            sb.append(j);
                            ans[i] = j;
                            break;
                        }
                    }
                } else if (i == n-1) { // 没有后缀字符
                    // 拿到前缀字符（修改后的）
                    char l = ans[n-2];
                    for (char j = 'a'; j <= 'z'; j++) {
                        if (j != l) {
                            sb.append(j);
                            ans[i] = j;
                            break;
                        }
                    }
                } else {
                    // 拿到前缀和后缀
                    char l = ans[i-1]; // 修改后的
                    char r = s.charAt(i+1);
                    for (char j = 'a'; j <= 'z'; j++) {
                        if (j != l && j != r) {
                            sb.append(j);
                            ans[i] = j;
                            break;
                        }
                    }
                }
            } else {
                sb.append(ch);
                ans[i] = ch;
            }
        }
        return sb.toString();
    }
}

这里我们在修改的同时，还得记录，因为字符串中没有修改过的，而我们是要在修改的基础上再进行判断修改的。因此我们便不采用 StringBuilder 的方式，而是直接在数组上进行修改即可。

java 复制代码 
class Solution {
    public String modifyString(String s) {
        char[] ans = s.toCharArray();
        int n = ans.length;
        for (int i = 0; i < n; i++) {
            char ch = ans[i];
            if (ch == '?') { // 需要修改
                for (char j = 'a'; j <= 'z'; j++) { // 找到可以替换的
                    // 前面的字符 和 后面的字符都满足即可
                    if ((i == 0 || j != ans[i-1]) && (i == n-1 || j != ans[i+1])) {
                        ans[i] = j;
                        break;
                    }
                }
            }
        }
        return new String(ans);
    }
}

495.提莫攻击

题目：

在《英雄联盟》的世界中，有一个叫 "提莫" 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。

当提莫攻击艾希，艾希的中毒状态正好持续 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 。

提示：

  • 1 <= timeSeries.length <= 104
  • 0 <= timeSeries[i], duration <= 107
  • timeSeries 按 非递减 顺序排列

思路：题目说了这么多，其实就是表达这样一个意思：有一个表示初始时间的数组，再来一个表示持续时长的数字，让我们求总共有多少秒。数组中的值有两类：一类是在初始时间到结束时间（加上持续时长）之内；还有一类是初始时间到结束时间之外。第二类，我们直接加上持续时间即可，而对于第一类我们要计算其有效时长：第二个初始时间 - 第一类初始时间。

代码实现：

java 复制代码 
class Solution {
    public int findPoisonedDuration1(int[] timeSeries, int duration) {
        int sum = 0;
        int n = timeSeries.length;
        for (int i = 0; i < n; i++) {
            // 判断中毒的时间是否是默认时长
            if (i+1 < n && timeSeries[i+1] < timeSeries[i]+duration) {
                sum += (timeSeries[i+1] - timeSeries[i]);
            } else {
                sum += duration;
            }
        }
        return sum;
    }
}

6.Z字形变换

题目：

将一个给定字符串 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"

提示：

  • 1 <= s.length <= 1000
  • s 由英文字母（小写和大写）、',' 和 '.' 组成
  • 1 <= numRows <= 1000

思路： 题目的意思是让我们把给的字符串，按照Z字形排列后，重新从上到下拼接出一个新的字符串。首先很容易想到的一个思路，就是直接用一个数组去接收字符串，然后再去遍历数组。

代码实现：

java 复制代码 
class Solution {
    public String convert(String s, int numRows) {
        // 当只有一行或者只有一列时，直接返回结果即可
        if (numRows == 1 || numRows >= s.length()) {
            return s;
        }
        // 1、做准备工作
        char[] str = s.toCharArray();
        char[][] ch = new char[numRows][1000];
        // Arrays.fill(ch, '*'); 这里不能直接去填充，fill方法只能填充一维数组
        // 如果要填充二维数组，只能遍历拿出一维数组，再去赋值了
        // 2、遍历字符串填充数组
        int index = 0;
        int len = str.length;
        int i = 0;
        int j = 0;
        while (index < len) {
            while (i < numRows-1) {
                if (index < len) {
                    ch[i++][j] = str[index++];
                } else {
                    break;
                }
            }
            while (i > 0) {
                if (index < len) {
                    ch[i--][j++] = str[index++];
                } else {
                    break;
                }
            }
        }
        // 3、从数组中拿值，拼凑字符串
        StringBuilder sb = new StringBuilder();
        for (i = 0; i < numRows; i++) {
            for (j = 0; j < 1000; j++) {
                // '\u0000' 这个是字符数组的默认值
                if (ch[i][j] != '\u0000') {
                    sb.append(ch[i][j]);
                }
            }
        }
        return sb.toString();
    }
}

上面的方法更容易想到，也是比较简单的方法，除此之外还有找规律的方法。

代码实现：

java 复制代码 
class Solution {
    public String convert(String s, int numRows) {
        // 当只有一行或者只有一列时，直接返回结果即可
        if (numRows == 1 || numRows > s.length()) {
            return s;
        }
        StringBuilder sb = new StringBuilder();
        int d = 2 * numRows - 2;
        int len = s.length();
        // 按照从上到下的顺序直接来计算
        // 第一行
        for (int i = 0; i < len; i += d) {
            sb.append(s.charAt(i));
        }
        // 中间行
        for (int k = 1; k < numRows-1; k++) { // k是行数
            // i 是前一个，j 是后一个，只要两者有一个是小于len的，就需要进入循环
            for (int i = k, j = d-k; i < len || j < len; i += d, j += d) {
                // 这里的顺序只能是先i后j
                if (i < len) {
                    sb.append(s.charAt(i));
                }
                if (j < len) {
                    sb.append(s.charAt(j));
                }
            }
        }
        // 最后一行
        for (int i = numRows-1; i < len; i += d) {
            sb.append(s.charAt(i));
        }
        return sb.toString();
    }
}

注意：在 Java中， 当声明一个基本数据类型的数组时，如果没有显式地为数组元素赋值，数组元素会被自动初始化为该数据类型的默认值。对于char类型的数组，其默认值是'\u0000'，这是一个空字符，其Unicode 值为 0。而不是**' '** ，这是空格字符，Unicode值是32。我们认为的空字符应该是 '' ，但是这种写法在Java中时符合语法规范的。Java中，字符的定义是 必须用单引号括起来且单引号内必须有且仅有一个字符。

38.外观数列

题目：

「外观数列」是一个数位字符串序列，由递归公式定义：

  • 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"

解释：

这是基本情况。

提示：

  • 1 <= n <= 30

思路： 如果不仔细阅读，这个题目的意思还是有点让人捉摸不透。根据示例的解释，我们可以明白题目给了一个参数n，让我们求n在经过函数计算之后的字符串是啥，第一项是"1"，这是固定的，后面的项就是根据前面一项的"读"出来的。

countAndSay(1) = "1" ------> 这是固定的。

countAndSay(2) = "1" 的行程长度编码 = "11" ------> 读前一项，一个1，即 11。

countAndSay(3) = "11" 的行程长度编码 = "21" ------> 读前一项，俩个个1，即 21。

countAndSay(4) = "21" 的行程长度编码 = "1211"------> 读前一项，一个2，一个1，即1211。

读的操作的过程：

因为 countAndSay(n) 是 countAndSay(n-1) 的行程长度编码，所以在计算第n项时，先得计算第n-1项，计算第n-1项，又得先计算第n-2项，....，直至计算到第1项。这个过程其实就是递归的。

代码实现：

java 复制代码 
class Solution {
    public String countAndSay(int n) {
        // 因为 countAndSay(n) 是 countAndSay(n-1) 的行程长度编码
        // 行程长度编码就是在"读"数据
        // 相当于求第n项，就是在"读"第n-1项
        
        if (n == 1) {
            return "1";
        }
        // 先拿到第n-1项的数据
        char[] ch = countAndSay(n-1).toCharArray();
        // 开始"读"数据：使用双指针分组数据
        StringBuilder sb = new StringBuilder();
        for (int left = 0, right = 0; right < ch.length;) {
            // 让 left 与 right 到达数组的两个边界
            // 注意：处理数组越界
            while (right < ch.length && ch[left] == ch[right]) {
                right++;
            }
            // 开始"读"操作
            sb.append(right-left);
            sb.append(ch[left]);
            // 开始新的分组
            left = right;
        }
        return sb.toString();
    }
}

1419. 数青蛙

题目：

给你一个字符串 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'

思路：题目是让我们遍历字符串，找到叫声数量最少的青蛙数，且青蛙在叫的过程中，严格遵守 c r o a k 的顺序。 即当我们遍历到某个叫声字符时，就可以去看看当前的前一个字符是否有青蛙已经叫过了。如果前一个字符没有青蛙叫过，那么这个叫声肯定不是青蛙的。如果前一个字符青蛙叫过了，那么处于当前字符的青蛙数++，处于前一个字符的青蛙数--。但是有个特殊的情况，我们得注意，当青蛙刚开始叫 c 这个字符时，既可以是前面已经叫完了的青蛙叫的，也可能是新的青蛙叫的，怎么判断呢？题目这里说的是最少数量，那么去判断处于 k字符的青蛙数量是否为0（因为当青蛙叫完之后，肯定是出于k字符的位置的），如果为0，则是有新的青蛙在叫，反之，则是剩余的青蛙在叫，那只需将 k字符的青蛙数--，c字符的青蛙数++。

总的来说，分两种情况，c字符，就是看是否有新的青蛙，其余字符就是看是否有处于前一个字符的青蛙。

代码实现：

java 复制代码 
class Solution {
    public int minNumberOfFrogs(String croakOfFrogs) {
        // 存储青蛙的叫声与此时的青蛙数量
        HashMap<Character, Integer> hash = new HashMap<>();
        hash.put('c', 0);
        hash.put('r', 0);
        hash.put('o', 0);
        hash.put('a', 0);
        hash.put('k', 0);
        // 遍历叫声，数青蛙
        char[] str = croakOfFrogs.toCharArray();
        int count = 0;
        for (int i = 0; i < str.length; i++) {
            char ch = str[i];
            // 判断当前字符的情况：
            // 1、起始字符，就看结束字符的数量；
            // 2、如果是中间字符，就看前一个字符的数量
            if (ch == 'c') {
                if (hash.getOrDefault('k', 0) != 0) { // 有空闲的青蛙
                    // 当前叫声的青蛙数++，空闲青蛙数--
                    hash.replace('c', hash.getOrDefault('c', 0)+1);
                    hash.replace('k', hash.get('k')-1);
                } else { // 没有空闲的青蛙，只能是新来了青蛙
                    hash.put('c', hash.getOrDefault('c', 0)+1);
                    count++;
                }
            } else if (ch == 'r') {
                // 判断是否有前一个字符
                if (hash.getOrDefault('c', 0) != 0) {
                    hash.replace('c', hash.get('c')-1);
                    hash.replace('r', hash.getOrDefault('r', 0)+1);
                } else {
                    return -1;
                }
            } else if (ch == 'o') {
                if (hash.getOrDefault('r', 0) != 0) {
                    hash.replace('r', hash.get('r')-1);
                    hash.replace('o', hash.getOrDefault('o', 0)+1);
                } else {
                    return -1;
                }
            } else if (ch == 'a') {
                if (hash.getOrDefault('o', 0) != 0) {
                    hash.replace('o', hash.get('o')-1);
                    hash.replace('a', hash.getOrDefault('a', 0)+1);
                } else {
                    return -1;
                }
            } else if (ch == 'k') {
                if (hash.getOrDefault('a', 0) != 0) {
                    hash.replace('a', hash.get('a')-1);
                    hash.replace('k', hash.getOrDefault('k', 0)+1);
                } else {
                    return -1;
                }
            } else { // 不是青蛙的叫声
                return -1;
            }
        }
        // 判断哈希表中是否还有剩余青蛙处于"叫"的状态
        // 这是通过测试用例排除出来的，为了偷懒只写了一部分，正常要把前面的叫声全部判断一遍
        if (hash.getOrDefault('a', 0) != 0 || hash.getOrDefault('c', 0) != 0) {
            return -1;
        }
        return count;
    }
}

上面的代码是根据思路直接写出来的，有点冗长，我们可以去尝试优化。

优化的地方：主要是多个if-else给去掉。而多个if-else存在的原因是我们不知道当前字符对应的青蛙数量。

java 复制代码 
class Solution {
    public int minNumberOfFrogs(String croakOfFrogs) {
        // 使用数组来记录当前叫声位置的青蛙数
        int[] count = new int[5];
        // 使用哈希表来记录索引
        HashMap<Character, Integer> hash = new HashMap<>();
        for (int i = 0; i < 5; i++) {
            hash.put("croak".charAt(i), i);
        }
        // 遍历叫声字符串
        int len = croakOfFrogs.length();
        char[] str = croakOfFrogs.toCharArray();
        for (int i = 0; i < len; i++) {
            // 判断当前字符是c字符，还是其他字符
            // 题目说了，不会出现其他无关字符，因此我们可以不用判断
            char ch = str[i];
            if (ch == 'c') {
                // 判断是否是剩余青蛙在叫
                if (count[hash.get('k')] != 0) {
                    count[hash.get('k')]--;
                }
                count[hash.get('c')]++;
            } else {
                // 判断是否有处于前一个叫声的青蛙
                if (count[hash.get(ch)-1] == 0) { // 注意这里的写法
                    return -1;
                }
                // 前一个叫声的青蛙数--，当前叫声的青蛙数++
                count[hash.get(ch)-1]--;
                count[hash.get(ch)]++;
            }
        }
        // 判断剩余叫声中是否有青蛙数，如果有，则不是青蛙叫声
        for (int i = 0; i < 5; i++) {
            if (count[i] != 0) {
                // 返回处于k位置的青蛙数即可
                return i == 4 ? count[i] : -1;
            }
        }
        return -1; // 这里只是为了通过编译
    }
}

好啦！本期 一文详解"模拟算法" 的学习之旅 就到此结束啦！我们下一期再一起学习吧！

相关推荐
疯狂的代M夫7 分钟前
数据结构 【带环链表2】
数据结构·链表
daily_233313 分钟前
数据结构——小小二叉树第二幕（二叉树链式结构的实现以及二叉树的遍历）超详细！！！
数据结构·c++
时光の尘20 分钟前
C语言菜鸟入门·关键字·void的用法
c语言·开发语言·c++·算法·c#·c·关键字
蚂蚁没问题s21 分钟前
图像处理 - 色彩空间转换
图像处理·人工智能·算法·机器学习·计算机视觉
戊子仲秋33 分钟前
【LeetCode】每日一题 2024_11_21 矩阵中的蛇（模拟）
算法·leetcode·矩阵
HP-Patience37 分钟前
【机器学习】- 模型复杂度vs模型误差
python·算法·机器学习
螺旋天光极锐斩空闪壹式！1 小时前
第十三课 二维数组（2）方向数组
开发语言·c++·算法
peter80151 小时前
算法项目推荐
算法
小小白白蛆1 小时前
剑指offer JZ51 数组中的逆序对
数据结构·算法·排序算法
十五年专注C++开发1 小时前
C++不完整类型（Incomplete Type）的检测与避免
开发语言·c++·算法·设计模式
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06RAG 实践- Ollama+RagFlow 部署本地知识库07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO1004 - matlab m_map地学绘图工具基础函数 - 设置网格