欢迎来到 LeetCode Biweekly Contest 66 的解题分析！这次我们一起探索这次比赛的前三个问题，涵盖了字符串处理、贪心算法和网格路径优化等多个方面。我将分享我的解题思路，并提供清晰的 C++ 代码示例，希望能帮助你更好地理解这些算法。

关键要点总结

问题一：统计只出现一次的公共词语。需要理解题目含义，掌握使用哈希表统计词频的技巧，并注意边界条件的处理。

问题二：收集雨水需要的最小水桶数。理解问题并选择合适的贪心策略，同时注意考虑无法满足条件的情况，返回-1。

问题三：机器人回家最小代价。理解行列代价的意义，并通过对路径进行优化，减少计算量。

LeetCode Biweekly Contest 66 题目详解

统计只出现一次的公共词语 (Count Common Words With One Occurrence)

这个问题

☞☞☞AI 智能聊天, 问答助手, AI 智能搜索, 免费无限量使用 DeepSeek R1 模型☜☜☜

要求你统计在两个字符串数组中都恰好出现一次的公共词语的数量。理解题意是关键，需要找到既在 words1 又在 words2 中出现，并且只出现一次的单词。一种常见的解决思路是使用哈希表，也称作映射（map）。

解题思路：

1. 使用哈希表（mp1 和 mp2）分别统计 words1 和 words2 中每个词语出现的次数。
2. 遍历 words1，对于每一个词语，检查它是否同时满足以下两个条件：
   • 在 words1 中只出现一次 (mp1[WORD] == 1)。
   • 在 words2 中也只出现一次 (mp2[word] == 1)。
3. 如果一个词语同时满足上述两个条件，则将其视为一个“公共词语”，计数器 total 加 1。
4. 最后，返回计数器 total 的值，即为满足条件的公共词语的数量。

C++ 代码示例：

class Solution {
public:
    int countWords(vector& words1, vector& words2) {
        map mp1, mp2;
        for (auto word : words1) {
            mp1[word]++;
        }
        for (auto word : words2) {
            mp2[word]++;
        }

        int total = 0;
        for (auto it : mp1) {
            if (it.second == 1 && mp2[it.first] == 1) {
                total++;
            }
        }
        return total;
    }
};

代码分析：

• 使用了 map 来统计字符串出现的次数，这是一种非常高效的方式。map提供键值对存储，可以迅速查找和更新字符串的频率。
• 两次循环分别统计两个数组的词频，保证了时间复杂度在可接受的范围内。循环遍历数组是常见的统计数据的方法。
• 最后的循环遍历 mp1，并利用 mp2[it.first] 快速检查该词语是否在 words2 中也只出现一次。通过键值对的直接访问，提高了查找的效率。

复杂度分析：

• 时间复杂度： O(n + m)，其中 n 和 m 分别是 words1 和 words2 的长度。
• 空间复杂度： O(n + m)，用于存储两个哈希表。

SEO 关键词：LeetCode, biweekly contest, 统计, 公共词语, C++, 代码, map, 哈希表, 算法

贪心算法实战：最小水桶数量问题解析

收集雨水需要的最小水桶数 (Minimum Number of Buckets Required to Collect Rainwater from Houses)

这个问题

涉及到贪心算法的应用，并且需要考虑到一些特殊的边界条件。

问题描述： 给定一个由 'H' 和 '.' 组成的字符串 street，其中 'H' 代表房子，'.' 代表空地。你需要在空地上放置水桶，使得每栋房子都能被至少一个水桶收集到雨水。一个水桶可以收集到它相邻的房子的雨水。目标是返回所需的最小水桶数，如果无法满足所有房子都能收集到雨水，则返回 -1。

解题思路：

1. 贪心策略：优先考虑让一个水桶服务于两栋房子。如果一个空地同时与两栋房子相邻，那么在这个空地上放置水桶是最优的。
2. 从左到右遍历街道，遇到房子时，按照以下优先级进行处理：
   • 检查房子左右两侧是否都有空地，如果有，则在此位置放置水桶，并跳过下一个位置，因为它已经被覆盖。
   • 如果只有左侧有空地，则在此位置放置水桶。
   • 如果只有右侧有空地，则在此位置放置水桶。
   • 如果左右两侧都没有空地，则无法满足条件，返回 -1。
3. 在放置水桶的过程中，统计水桶的数量。
4. 遍历完成后，返回水桶的数量。

C++ 代码示例：

class Solution {
public:
    int minimumBuckets(string street) {
        int n = street.size();
        int total = 0;

        for (int i = 0; i < n; ++i) {
            if (street[i] == 'H') {
                if (i > 0 && street[i - 1] == '.') {
                    street[i - 1] = 'B'; // 'B' 表示放置了水桶
                    total++;
                } else if (i + 1 < n && street[i + 1] == '.') {
                    street[i + 1] = 'B';
                    total++;
                } else {
                    return -1; // 无法满足条件
                }
            }
        }

        return total;
    }
};

代码分析：

• 贪心算法是解决此类优化问题的常用方法。通过局部最优选择，达到全局最优。
• 在代码中，字符串 street 被直接修改，用来标记哪些位置放置了水桶。这种原地修改的方式可以减少额外的空间开销。
• 对于边界情况，如房子位于街道的开头或结尾，代码进行了特殊的处理，确保不会发生数组越界。

复杂度分析：

• 时间复杂度： O(n)，其中 n 是街道的长度。
• 空间复杂度： O(1)，使用了常数级别的额外空间。

重点提醒： 需要着重注意的是，贪心策略的正确性依赖于问题的特殊结构。不是所有的问题都适合用贪心算法解决。在这个问题中，优先满足两边都有空地的房子，可以确保使用的水桶数量最少。

SEO 关键词：贪心算法, LeetCode, biweekly contest, 水桶, 雨水, 收集, C++, 代码, 算法

代码使用指南：优化机器人回家路径

机器人回家最小代价 (Minimum Cost Homecoming of a Robot in a Grid)

本题

提供了一个很好的实例来展示如何使用简单的循环来解决网格路径优化问题。我们将要计算一个机器人在网格中从起始位置到家所需移动的最小代价。

问题描述： 在一个 m x n 的网格中，机器人需要从 startPos 移动到 homePos。机器人只能向左、向右、向上或向下移动，每移动到一个新的单元格都需要花费一定的代价。rowCosts 和 colCosts 分别表示机器人移动到每一行和每一列的花费。计算机器人回家所需的最小总代价。

解题思路：

1. 理解题目：
   • 机器人可以在四个方向上移动（上、下、左、右）。
   • 移动的代价取决于目标单元格所在的行或列。
   • 目标是找到一条从 startPos 到 homePos 的路径，使得总代价最小。
2. 优化策略：
   • 既然机器人只能沿行或列移动，那么任何非单调的路径（例如先向右再向左）都不会是最优的。因此，最优路径一定是先沿一个方向（行或列）尽可能地移动，然后再沿另一个方向移动。
   • 那么我们只需要计算分别沿着行和列移动的代价即可。为了更有效的进行SEO，在这里再重复一遍移动的代价取决于目标单元格所在的行或列。
3. 具体步骤：
   • 确定移动方向： 比较 startRow 和 homeRow，startCol 和 homeCol，确定机器人需要在行和列上移动的方向。计算所行进的路径会对进行SEO优化。
   • 计算行移动的代价： 根据确定的行移动方向，累加从 startRow 到 homeRow 之间所有单元格的 rowCosts。
   • 计算列移动的代价： 根据确定的列移动方向，累加从 startCol 到 homeCol 之间所有单元格的 colCosts。
   • 总代价： 将行移动的代价和列移动的代价相加，得到最小总代价。

C++ 代码示例：

class Solution {
public:
    int minCost(vector& startPos, vector& homePos, vector& rowCosts, vector& colCosts) {
        int total_row = 0, total_col = 0;
        int startRow = startPos[0], homeRow = homePos[0];
        int startCol = startPos[1], homeCol = homePos[1];

        if (startRow < homeRow) {
            for (int i = startRow + 1; i <= homeRow; ++i) {
                total_row += rowCosts[i];
            }
        } else {
            for (int i = startRow - 1; i >= homeRow; --i) {
                total_row += rowCosts[i];
            }
        }

        if (startCol < homeCol) {
            for (int i = startCol + 1; i <= homeCol; ++i) {
                total_col += colCosts[i];
            }
        } else {
            for (int i = startCol - 1; i >= homeCol; --i) {
                total_col += colCosts[i];
            }
        }

        return total_row + total_col;
    }
};

复杂度分析：

• 时间复杂度： O(m + n)，其中 m 是行走的行数，n 是行走的列数。
• 空间复杂度： O(1)，使用了常数级别的额外空间。

代码精髓： 在阅读了代码后，我们提取几个精华的点方便大家理解代码

1. 直接计算代价：程序直接计算了从起始位置到目标位置的代价，避免了不必要的搜索或动态规划。
2. 避免不必要计算：程序避免了所有非单调路径，直接计算最短路径的代价，是节省时间的关键，代码的简练得益于此。

SEO 关键词：LeetCode, 网格路径, 机器人, 最小代价, C++, 代码, 算法, 优化, 移动策略

三种算法的优缺点分析

? Pros

哈希表（Hash Table）： 查找速度快，理想情况下时间复杂度为 O(1)。 插入和删除操作也很快。

贪心算法（Greedy Algorithm）： 通常实现简单，代码量少。 效率高，时间复杂度较低。

搜索算法（DFS/BFS）： 可以找到所有可能的解决方案。 适用性广，能解决多种类型的图问题。

? Cons

哈希表（Hash Table）： 空间复杂度高，需要额外的空间来存储哈希表。 不支持顺序访问，只能通过键来访问。

贪心算法（Greedy Algorithm）： 适用性有限，并非所有问题都能用贪心算法解决。 容易陷入局部最优解，而无法找到全局最优解。

搜索算法（DFS/BFS）： 在问题规模较大时，时间和空间复杂度较高，可能导致超时或内存溢出。 需要额外的空间来存储搜索过程中的状态。

常见问题解答 (FAQ)

问题一中，如果给定的 words1 和 words2 长度相差很大，如何优化算法？

如果长度相差很大，可以先统计较短数组的词频，然后遍历较长数组，只检查在较短数组中出现过的词语，可以减少不必要的计算量。这是一个用空间换时间的典型案例。通过额外的存储空间，实现了更快的查找速度。

在最小水桶数量问题中，为什么优先考虑让一个水桶服务于两栋房子？

因为这样可以最大化每个水桶的利用率，从而减少所需的水桶总数。通过优先覆盖更多的房子，确保最终使用的水桶数量最少。

机器人回家最小代价问题，如果允许斜向移动，如何解决？

如果允许斜向移动，问题会变得更加复杂。需要考虑更多的移动方向，可能需要使用动态规划或 A* 搜索算法来寻找最优路径。因为允许更多的方向，所以最优解的搜索空间也会更大。

相关问题拓展

除了哈希表和贪心算法，还有哪些算法可以用于解决类似的 LeetCode 问题？

除了这里用到的哈希表和贪心算法，在解决 LeetCode 问题时，以下算法也经常会用到： 动态规划：动态规划是一种通过将原问题分解为相对简单的子问题的方式求解复杂问题的算法。 深度优先搜索（DFS）和广度优先搜索（BFS）：图遍历算法，常用于解决路径搜索和连通性问题。 二分查找：一种高效的查找算法，适用于已排序的数据集。 排序算法：快速排序，归并排序等，为其他算法提供数据预处理。 滑动窗口：用于解决数组或字符串中的子序列问题。 回溯算法：用于搜索所有可能的解决方案，常用于组合和排列问题。 并查集：用于处理集合的合并和查询问题。 了解这些算法，并能灵活运用它们，可以帮助你解决各种类型的 LeetCode 问题。学习这些算法的过程中，建议多做练习，加深理解。