Day2 题解：小D的abc变换问题| 豆包MarsCode AI刷题

小D的abc变换问题

问题描述

小D拿到了一个仅由 "abc" 三种字母组成的字符串。她每次操作会对所有字符同时进行以下变换：

• 将 'a' 变成 'bc'
• 将 'b' 变成 'ca'
• 将 'c' 变成 'ab'

小D将重复该操作 k 次。你的任务是输出经过 k 次变换后，得到的最终字符串。

例如：对于初始字符串 "abc"，执行 2 次操作后，字符串将变为 "caababbcbcca"。

测试样例

• 样例1：

  • 输入：s = "abc", k = 2
  • 输出："caababbcbcca"

• 样例2：

  • 输入：s = "abca", k = 3
  • 输出："abbcbccabccacaabcaababbcabbcbcca"

• 样例3：

  • 输入：s = "cba", k = 1
  • 输出："abcabc"

解题思路

本题需要对字符串进行 k 次的字符替换操作。每次操作都根据字符的映射规则将字符串中的每个字符替换成一个新的字符串。由于每次操作都会使字符串长度变倍，随着 k 的增大，字符串的长度会指数级增长，因此需要特别关注时间和空间复杂度。

1. 字符映射规则：

   • 'a' → 'bc'
   • 'b' → 'ca'
   • 'c' → 'ab'

2. 逐步变换：

   • 每次遍历字符串，将每个字符根据上述规则替换，并且将结果拼接成新的字符串。

3. 字符串扩展：

   • 每次变换后，字符串的长度会变大，字符串的长度是指数级增长的。因此，复杂度会受到变换次数 k 的影响。

代码实现与详解

以下是完整的 Java 代码，使用字符串替换规则进行多次变换：

java
复制代码
public class Main {
    public static String solution(String s, int k) {
        // 对字符串进行 k 次变换
        for (int i = 0; i < k; i++) {
            StringBuilder temp = new StringBuilder();
            for (int j = 0; j < s.length(); j++) {
                switch(s.charAt(j)) {
                    case 'a':
                        temp.append("bc");
                        break;
                    case 'b':
                        temp.append("ca");
                        break;
                    case 'c':
                        temp.append("ab");
                        break;
                }
            }
            s = temp.toString();  // 更新字符串为变换后的新字符串
        }
        return s;
    }

    public static void main(String[] args) {
        // 测试用例
        System.out.println(solution("abc", 2).equals("caababbcbcca"));  // 输出：caababbcbcca
        System.out.println(solution("abca", 3).equals("abbcbccabccacaabcaababbcabbcbcca")); // 输出：abbcbccabccacaabcaababbcabbcbcca
        System.out.println(solution("cba", 1).equals("abcabc"));  // 输出：abcabc
    }
}

代码详解

1. StringBuilder：

   • 使用 StringBuilder 来逐个拼接新的字符串，避免每次使用 + 运算符拼接时生成新的字符串，减少性能开销。

2. 变换逻辑：

   • 通过 switch 语句，根据当前字符替换成对应的字符串（bc、ca 或 ab）。

3. 循环控制：

   • 外层循环控制变换的次数 k，内层循环遍历字符串，进行字符替换。

4. 返回结果：

   • 每次变换结束后，更新字符串 s，直到完成所有变换。

时间复杂度分析

• 每次变换：每次遍历字符串的每一个字符，根据替换规则生成新的字符串。假设初始字符串长度为 n，每次变换后，字符串的长度会变为 2n（每个字符会变成两个字符）。
• 时间复杂度：每次变换的时间复杂度是 O(n)，因此，执行 k 次变换后的总时间复杂度为： O(n⋅2k)O(n \cdot 2^k)O(n⋅2k) 其中 n 是初始字符串的长度。

空间复杂度分析

• 空间使用：每次变换后，我们需要一个新的字符串来存储变换后的结果。变换后的字符串的长度会变为原来的两倍。因此，空间复杂度为 O(n * 2^k)，其中 n 是初始字符串的长度。

总结

• 时间复杂度：O(n * 2^k)
• 空间复杂度：O(n * 2^k)