题目解析：小U的数字插入问题 | 豆包MarsCode AI刷题

木火通明
136 阅读6分钟

问题描述

给定一个字符串 s，其中仅包含英文字母（包括大小写字母）。我们的任务是计算最多可以从中组成多少个字符串 "ku"。组成 "ku" 的条件如下：

  1. 字符选择：每次可以从字符串中随机选取一个字符，但选中的字符不能再次使用。
  2. 不区分大小写：大写字母和小写字母被视为相同，例如 'K' 和 'k' 被认为是相同的字符，'U' 和 'u' 也是如此。
  3. 组成方式：每个 "ku" 需要一个 'k' 和一个 'u' 字符。

示例解释：

  • 输入 "AUBTMKAxfuu" 转换为小写后为 "aubtmkaxfuu"。其中 'k' 出现一次，'u' 出现两次，因此最多只能组成一个 "ku"。
  • 输入 "KKuuUuUuKKKKkkkkKK" 转换为小写后为 "kkuuuuuukkkkkkkkkk"。其中 'k' 出现12次，'u' 出现6次，因此最多可以组成6个 "ku"。
  • 输入 "abcdefgh" 转换为小写后为 "abcdefgh"。其中 'k' 和 'u' 都未出现，因此无法组成任何 "ku"。

解题思路

为了求解这个问题，我们需要明确如何高效地计算出可以组成 "ku" 的最大数量。下面是详细的思路步骤：

  1. 统一字符大小写：

    • 由于题目要求大小写不敏感，我们需要将整个字符串转换为同一种大小写（全小写或全大写）以简化后续的字符比较。
    • 选择将字符串转换为全小写，因为小写字母通常更直观。

  2. 统计关键字符：

    • 遍历转换后的字符串，统计其中 'k' 和 'u' 的出现次数。这两个字符是组成 "ku" 的必要条件。
    • 可以使用两个计数器分别记录 'k' 和 'u' 的数量。

  3. 确定最大组成数量：

    • 每个 "ku" 需要一个 'k' 和一个 'u'，因此能够组成的 "ku" 的数量取决于 'k' 和 'u' 两者中较小的一个。
    • 例如，如果 'k' 有5个，'u' 有3个，那么最多可以组成3个 "ku"。

  4. 边界情况处理：

    • 如果字符串中没有 'k' 或 'u'，那么无法组成任何 "ku"，结果应为0。
    • 字符串可能非常长，需要保证算法的效率。

详细步骤与实现

下面我们将详细阐述每一步的具体实现和考虑因素。

1. 统一字符大小写

在编程中，字符的大小写通常会影响比较操作。为了避免大小写带来的复杂性，我们将整个字符串统一转换为小写。这一步确保我们只需关注小写字符 'k' 和 'u'，无需同时处理大写和小写的情况。

String lowerCaseStr = s.toLowerCase();

2. 统计关键字符

遍历转换后的字符串，统计 'k' 和 'u' 的数量。可以通过以下方式实现：

  • 初始化两个计数器 countK 和 countU，分别用于统计 'k' 和 'u' 的出现次数。
  • 使用 for-each 循环遍历字符串的每一个字符。
  • 对每个字符进行判断，如果是 'k'，则 countK 加1；如果是 'u'，则 countU 加1。
int countK = 0;
int countU = 0;

for (char c : lowerCaseStr.toCharArray()) {
    if (c == 'k') {
        countK++;
    } else if (c == 'u') {
        countU++;
    }
}

3. 确定最大组成数量

一旦我们获得了 'k' 和 'u' 的数量，最大可以组成的 "ku" 的数量就是两者的较小值。因为每个 "ku" 需要一个 'k' 和一个 'u'。

return Math.min(countK, countU);

4. 综合考虑时间与空间复杂度

  • 时间复杂度：整个算法的时间复杂度为O(n)，其中n是字符串的长度。因为我们需要遍历整个字符串一次来统计 'k' 和 'u' 的数量。
  • 空间复杂度：空间复杂度为O(1)，即常数空间。我们只使用了两个变量来存储计数器，不随输入规模变化。

这种时间和空间效率对于处理大规模字符串也是非常有效的。

示例详细分析

让我们通过具体的示例来更深入地理解算法的执行过程。

示例1：

输入：s = "AUBTMKAxfuu"

步骤：

  1. 转换为小写："aubtmkaxfuu"

  2. 统计字符：

    • 'k' 出现次数：1
    • 'u' 出现次数：2

  3. 计算结果：min(1, 2) = 1

结果：可以组成1个 "ku"。

示例2：

输入：s = "KKuuUuUuKKKKkkkkKK"

步骤：

  1. 转换为小写："kkuuuuuukkkkkkkkkk"

  2. 统计字符：

    • 'k' 出现次数：12
    • 'u' 出现次数：6

  3. 计算结果：min(12, 6) = 6

结果：可以组成6个 "ku"。

示例3：

输入：s = "abcdefgh"

步骤：

  1. 转换为小写："abcdefgh"

  2. 统计字符：

    • 'k' 出现次数：0
    • 'u' 出现次数：0

  3. 计算结果：min(0, 0) = 0

结果：无法组成任何 "ku"。

代码实现

结合上述的详细步骤，以下是完整的Java代码实现：

public class Main {
    public static int solution(String s) {
        // 将字符串转换为小写，忽略大小写
        String lowerCaseStr = s.toLowerCase();
        int countK = 0;
        int countU = 0;
        
        // 遍历字符串，统计 'k' 和 'u' 的数量
        for (char c : lowerCaseStr.toCharArray()) {
            if (c == 'k') {
                countK++;
            } else if (c == 'u') {
                countU++;
            }
        }
        
        // 返回 'k' 和 'u' 数量中的较小值
        return Math.min(countK, countU);
    }

    public static void main(String[] args) {
        System.out.println(solution("AUBTMKAxfuu") == 1); // 输出：true
        System.out.println(solution("KKuuUuUuKKKKkkkkKK") == 6); // 输出：true
        System.out.println(solution("abcdefgh") == 0); // 输出：true
    }
}

进一步优化与扩展

虽然上述算法已经能够高效地解决问题，但在实际应用中，我们可能需要考虑一些扩展和优化。

1. 使用哈希表进行字符统计

如果需要统计多个字符的频率，使用哈希表（如 HashMap<Character, Integer>）会更加灵活。然而，在本题中，我们只需要统计 'k' 和 'u'，因此直接使用两个变量更为高效。

2. 早期终止

在遍历字符串时，如果已经知道某一字符的数量已经不足以组成更多的 "ku"，可以提前终止遍历以节省时间。不过，由于需要遍历整个字符串才能确保所有 'k' 和 'u' 的数量，实际中这种优化收益有限。

3. 处理非字母字符

虽然题目中明确指出字符串只包含英文字母，但在实际应用中，可能需要处理包含其他字符的字符串。可以在统计时忽略非字母字符，或根据需求进行处理。

for (char c : lowerCaseStr.toCharArray()) {
    if (!Character.isLetter(c)) {
        continue; // 忽略非字母字符
    }
    if (c == 'k') {
        countK++;
    } else if (c == 'u') {
        countU++;
    }
}

4. 扩展到其他模式匹配

如果需要统计可以组成其他特定字符串（如 "abc"、"hello" 等），可以扩展算法，统计每个目标字符串中所需的字符频率，并取相应的最小值。例如，要统计 "abc"，需要统计 'a'、'b' 和 'c' 的数量，并取最小值作为可以组成的 "abc" 的数量。

总结

本题通过简单的字符统计和最小值计算，便捷地解决了最大可组成 "ku" 的数量问题。关键在于：

  1. 统一字符大小写，简化比较操作。
  2. 高效统计，仅关注必要的字符。
  3. 逻辑清晰，通过最小值确定结果。

这种方法不仅适用于本题，还可以推广到其他类似的字符频率统计和模式匹配问题中。

avatar
文章
阅读
粉丝