Every day a Leetcode

题目来源：2391. 收集垃圾的最少总时间

解法1：前缀和

收集垃圾的时间分为两部分：

1. 垃圾车收拾垃圾的时间：垃圾车收拾一单位的任何一种垃圾都需要花费 1 分钟。
2. 三辆垃圾车行驶的时间：每辆垃圾车都从房子 0 出发，按顺序到达每一栋房子，直到最后出现相应垃圾的房子。

算法：

1. 初始化总时间 sum = 0，用一个 last[3] 数组分别记录三种垃圾的最后出现下标。
2. 遍历数组 garbage，对于每一个字符串 gar，先加上收拾垃圾的时间 sum += gar.length()，再根据里面的字符更新 last 数组。
3. 用一个 pre 数组记录 travel 的前缀和。
4. 遍历 last 数组，每一辆垃圾车都从 0 出发，到达 last[i] 结束，加上垃圾车行驶的时间 sum += pre[last[i]] - pre[0]。
5. 最后，sum 即为答案。

代码：

/*
 * @lc app=leetcode.cn id=2391 lang=cpp
 *
 * [2391] 收集垃圾的最少总时间
 */

// @lc code=start
class Solution
{
public:
    int garbageCollection(vector<string> &garbage, vector<int> &travel)
    {
        int n = garbage.size();
        int sum = 0;
        vector<int> last(3, -1); // m、p、g 最后出现的下标
        for (int i = 0; i < n; i++)
        {
            string gar = garbage[i];
            sum += gar.length(); // 收拾垃圾的时间
            int m = 0, p = 0, g = 0;
            for (char &c : gar)
            {
                if (c == 'M')
                    last[0] = i;
                else if (c == 'P')
                    last[1] = i;
                else
                    last[2] = i;
            }
        }
        // 路径长度前缀和
        vector<int> pre(n, 0);
        for (int i = 1; i < n; i++)
            pre[i] = pre[i - 1] + travel[i - 1];
        for (int i = 0; i < 3; i++)
            if (last[i] != -1)
                sum += pre[last[i]] - pre[0]; // 行驶的时间
        return sum;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(n+L+m+k)，其中 n 是数组 garbage 的元素个数，L 是数组 garbage 的字符串长度总和，m 是数组 travel 的长度，k=3 表示垃圾种类数。

空间复杂度：O(m+k)，其中 m 是数组 travel 的长度，k=3 表示垃圾种类数。

解法2：一次遍历

我们可以在遍历 garbage 的同时，计算从房子 0 到房子 i 的用时 time，以及一个哈希表（或者数组）drive 记录每辆车目前的行驶用时。例如 garbage[i]=GP，那么收集 G 和 P 的垃圾车的行驶用时更新为 time，收集 M 的垃圾车的行驶用时不变。循环结束后，drive 中保存的就是每辆垃圾车各自的行驶用时了。

最后答案为所有 garbage[i] 的长度之和，加上 drive 中保存的行驶用时之和。

在遍历 garbage 的过程中把行驶时间加入答案，从而做到一次遍历。

代码：

class Solution
{
public:
    int garbageCollection(vector<string> &garbage, vector<int> &travel)
    {
        int n = garbage.size();
        int sum = garbage[0].length();
        int time = 0; // 行驶时间
        // 每辆垃圾车的行驶时间
        unordered_map<char,int> drive;
        for (int i = 1; i < n; i++)
        {
            string gar = garbage[i];
            sum += gar.length(); // 收拾垃圾的时间
            time += travel[i - 1];
            for (char &c : gar)
            {
                // 更新垃圾对应垃圾车的行驶时间
                sum += time - drive[c];
                drive[c] = time;
            }
        }
        return sum;
    }
};

结果：

复杂度分析：

时间复杂度：O(n+L+k)，其中 n 是数组 garbage 的元素个数，L 是数组 garbage 的字符串长度总和，k=3 表示垃圾种类数。

空间复杂度：O(m+k)，其中 m 是数组 travel 的长度，k=3 表示垃圾种类数。