feat: add solutions to lc problem: No.2391

No.2391.Minimum Amount of Time to Collect Garbage

Author: yanglbme

solution/2300-2399/2391.Minimum Amount of Time to Collect Garbage/README.md

@@ -72,6 +72,11 @@
 
 由于题目中说明同一时刻只有一辆车处于使用状态，因此我们直接模拟每辆车的运行过程，累加时间。
 
+更进一步思考，我们发现，答案的总耗时其实可以分成两部分：
+
+1. 所有垃圾的数量，我们遍历 `garbage` 中的每一项 `v`，然后累加 `v.length` 就能得到；
+1. 根据每一种垃圾在 `garbage` 中最后一次出现的位置 `i`，我们累加 `travel[0..i)` 即可。这里可以先算出 `travel` 的前缀和。
+
 时间复杂度 $O(n)$，其中 $n$ 为垃圾的数量。
 
 <!-- tabs:start -->
@@ -100,6 +105,20 @@ class Solution:
         return f('M') + f('P') + f('G')
 ```
 
+```python
+class Solution:
+    def garbageCollection(self, garbage: List[str], travel: List[int]) -> int:
+        ans = 0
+        pos = {}
+        for i, v in enumerate(garbage):
+            ans += len(v)
+            for c in v:
+                pos[c] = i
+        s = list(accumulate(travel, initial=0))
+        ans += sum(s[i] for i in pos.values())
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -146,6 +165,29 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int garbageCollection(String[] garbage, int[] travel) {
+        int ans = 0;
+        int[] pos = new int[26];
+        for (int i = 0; i < garbage.length; ++i) {
+            ans += garbage[i].length();
+            for (char c : garbage[i].toCharArray()) {
+                pos[c - 'A'] = i;
+            }
+        }
+        int[] s = new int[travel.length + 1];
+        for (int i = 0; i < travel.length; ++i) {
+            s[i + 1] = s[i] + travel[i];
+        }
+        for (int i : pos) {
+            ans += s[i];
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -183,6 +225,30 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int garbageCollection(vector<string>& garbage, vector<int>& travel) {
+        int ans = 0;
+        vector<int> pos(26);
+        for (int i = 0; i < garbage.size(); ++i) {
+            ans += garbage[i].size();
+            for (char c : garbage[i]) {
+                pos[c - 'A'] = i;
+            }
+        }
+        vector<int> s(travel.size() + 1);
+        for (int i = 0; i < travel.size(); ++i) {
+            s[i + 1] = s[i] + travel[i];
+        }
+        for (int i : pos) {
+            ans += s[i];
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -220,6 +286,27 @@ func garbageCollection(garbage []string, travel []int) int {
 }
 ```
 
+```go
+func garbageCollection(garbage []string, travel []int) int {
+	ans := 0
+	pos := map[rune]int{}
+	for i, v := range garbage {
+		ans += len(v)
+		for _, c := range v {
+			pos[c] = i
+		}
+	}
+	s := make([]int, len(travel)+1)
+	for i, v := range travel {
+		s[i+1] = s[i] + v
+	}
+	for _, i := range pos {
+		ans += s[i]
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -259,6 +346,27 @@ function garbageCollection(garbage: string[], travel: number[]): number {
 }
 ```
 
+```ts
+function garbageCollection(garbage: string[], travel: number[]): number {
+    let ans = 0;
+    let pos = new Map();
+    for (let i = 0; i < garbage.length; ++i) {
+        ans += garbage[i].length;
+        for (const c of garbage[i]) {
+            pos.set(c, i);
+        }
+    }
+    let s = new Array(travel.length + 1).fill(0);
+    for (let i = 0; i < travel.length; ++i) {
+        s[i + 1] = s[i] + travel[i];
+    }
+    for (const [_, i] of pos) {
+        ans += s[i];
+    }
+    return ans;
+}
+```
+
 ### **Rust**
 
 ```rust

solution/2300-2399/2391.Minimum Amount of Time to Collect Garbage/README_EN.md

@@ -88,6 +88,20 @@ class Solution:
         return f('M') + f('P') + f('G')
 ```
 
+```python
+class Solution:
+    def garbageCollection(self, garbage: List[str], travel: List[int]) -> int:
+        ans = 0
+        pos = {}
+        for i, v in enumerate(garbage):
+            ans += len(v)
+            for c in v:
+                pos[c] = i
+        s = list(accumulate(travel, initial=0))
+        ans += sum(s[i] for i in pos.values())
+        return ans
+```
+
 ### **Java**
 
 ```java
@@ -132,6 +146,29 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int garbageCollection(String[] garbage, int[] travel) {
+        int ans = 0;
+        int[] pos = new int[26];
+        for (int i = 0; i < garbage.length; ++i) {
+            ans += garbage[i].length();
+            for (char c : garbage[i].toCharArray()) {
+                pos[c - 'A'] = i;
+            }
+        }
+        int[] s = new int[travel.length + 1];
+        for (int i = 0; i < travel.length; ++i) {
+            s[i + 1] = s[i] + travel[i];
+        }
+        for (int i : pos) {
+            ans += s[i];
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -169,6 +206,30 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int garbageCollection(vector<string>& garbage, vector<int>& travel) {
+        int ans = 0;
+        vector<int> pos(26);
+        for (int i = 0; i < garbage.size(); ++i) {
+            ans += garbage[i].size();
+            for (char c : garbage[i]) {
+                pos[c - 'A'] = i;
+            }
+        }
+        vector<int> s(travel.size() + 1);
+        for (int i = 0; i < travel.size(); ++i) {
+            s[i + 1] = s[i] + travel[i];
+        }
+        for (int i : pos) {
+            ans += s[i];
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -206,6 +267,27 @@ func garbageCollection(garbage []string, travel []int) int {
 }
 ```
 
+```go
+func garbageCollection(garbage []string, travel []int) int {
+	ans := 0
+	pos := map[rune]int{}
+	for i, v := range garbage {
+		ans += len(v)
+		for _, c := range v {
+			pos[c] = i
+		}
+	}
+	s := make([]int, len(travel)+1)
+	for i, v := range travel {
+		s[i+1] = s[i] + v
+	}
+	for _, i := range pos {
+		ans += s[i]
+	}
+	return ans
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -245,6 +327,27 @@ function garbageCollection(garbage: string[], travel: number[]): number {
 }
 ```
 
+```ts
+function garbageCollection(garbage: string[], travel: number[]): number {
+    let ans = 0;
+    let pos = new Map();
+    for (let i = 0; i < garbage.length; ++i) {
+        ans += garbage[i].length;
+        for (const c of garbage[i]) {
+            pos.set(c, i);
+        }
+    }
+    let s = new Array(travel.length + 1).fill(0);
+    for (let i = 0; i < travel.length; ++i) {
+        s[i + 1] = s[i] + travel[i];
+    }
+    for (const [_, i] of pos) {
+        ans += s[i];
+    }
+    return ans;
+}
+```
+
 ### **Rust**
 
 ```rust

solution/2300-2399/2391.Minimum Amount of Time to Collect Garbage/Solution.cpp

@@ -1,32 +1,21 @@
 class Solution {
 public:
-    vector<string> g;
-    vector<int> travel;
-
     int garbageCollection(vector<string>& garbage, vector<int>& travel) {
-        g = garbage;
-        this->travel = travel;
-        return f('M') + f('P') + f('G');   
-    }
-
-    int f(char c) {
-        int tot = 0;
-        for (string& v : g) {
-            for (char ch : v) {
-                tot += ch == c;
+        int ans = 0;
+        vector<int> pos(26);
+        for (int i = 0; i < garbage.size(); ++i) {
+            ans += garbage[i].size();
+            for (char c : garbage[i]) {
+                pos[c - 'A'] = i;
             }
         }
-        int res = 0;
-        for (int i = 0; i < g.size(); ++i) {
-            int t = 0;
-            for (char ch : g[i]) {
-                t += ch == c;
-            }
-            res += t;
-            tot -= t;
-            if (tot == 0) break;
-            if (i < g.size() - 1) res += travel[i];
+        vector<int> s(travel.size() + 1);
+        for (int i = 0; i < travel.size(); ++i) {
+            s[i + 1] = s[i] + travel[i];
+        }
+        for (int i : pos) {
+            ans += s[i];
         }
-        return res;
+        return ans;
     }
 };

solution/2300-2399/2391.Minimum Amount of Time to Collect Garbage/Solution.go

@@ -1,32 +1,18 @@
 func garbageCollection(garbage []string, travel []int) int {
-	n := len(garbage)
-	f := func(c rune) int {
-		tot := 0
-		for _, v := range garbage {
-			for _, ch := range v {
-				if ch == c {
-					tot++
-				}
-			}
+	ans := 0
+	pos := map[rune]int{}
+	for i, v := range garbage {
+		ans += len(v)
+		for _, c := range v {
+			pos[c] = i
 		}
-		res := 0
-		for i, v := range garbage {
-			t := 0
-			for _, ch := range v {
-				if ch == c {
-					t++
-				}
-			}
-			res += t
-			tot -= t
-			if tot == 0 {
-				break
-			}
-			if i < n-1 {
-				res += travel[i]
-			}
-		}
-		return res
 	}
-	return f('M') + f('P') + f('G')
+	s := make([]int, len(travel)+1)
+	for i, v := range travel {
+		s[i+1] = s[i] + v
+	}
+	for _, i := range pos {
+		ans += s[i]
+	}
+	return ans
 }