feat: add solutions to lc problem: No.1701

No.1701.Average Waiting Time

Author: yanglbme

solution/1700-1799/1701.Average Waiting Time/README.md

@@ -58,7 +58,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-记 totalWaitingTime 表示总等待时间，f 表示当次做菜完成时间。
+**方法一：模拟**
+
+我们用变量 `tot` 记录顾客的总等待时间，用变量 `t` 记录做完每个顾客的订单的时间，初始值均为 $0$。
+
+遍历顾客数组 `customers`，对于每个顾客：
+
+如果当前时间 `t` 小于等于顾客的到达时间 `customers[i][0]`，说明厨师没有在做菜，那么厨师可以立即开始做菜，做完这道菜的时间为 `t = customers[i][0] + customers[i][1]`，顾客的等待时间为 `customers[i][1]`。
+
+否则，说明厨师正在做菜，那么顾客需要等待厨师做完此前的菜，才能开始做自己的菜，做完这道菜的时间为 `t = t + customers[i][1]`，顾客的等待时间为 `t - customers[i][0]`。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为顾客数组 `customers` 的长度。
 
 <!-- tabs:start -->
 
@@ -69,11 +79,11 @@
 ```python
 class Solution:
     def averageWaitingTime(self, customers: List[List[int]]) -> float:
-        f = total_waiting_time = 0
-        for arrival, time in customers:
-            f = max(arrival, f) + time
-            total_waiting_time += f - arrival
-        return total_waiting_time / len(customers)
+        tot = t = 0
+        for a, b in customers:
+            t = max(t, a) + b
+            tot += t - a
+        return tot / len(customers)
 ```
 
 ### **Java**
@@ -83,14 +93,54 @@ class Solution:
 ```java
 class Solution {
     public double averageWaitingTime(int[][] customers) {
-        int f = 0;
-        double totalWaitingTime = 0;
-        for (int[] customer : customers) {
-            f = Math.max(f, customer[0]) + customer[1];
-            totalWaitingTime += (f - customer[0]);
+        double tot = 0;
+        int t = 0;
+        for (var e : customers) {
+            int a = e[0], b = e[1];
+            t = Math.max(t, a) + b;
+            tot += t - a;
+        }
+        return tot / customers.length;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    double averageWaitingTime(vector<vector<int>>& customers) {
+        double tot = 0;
+        int t = 0;
+        for (auto& e : customers) {
+            int a = e[0], b = e[1];
+            t = max(t, a) + b;
+            tot += t - a;
         }
-        return totalWaitingTime / customers.length;
+        return tot / customers.size();
     }
+};
+```
+
+### **Go**
+
+```go
+func averageWaitingTime(customers [][]int) float64 {
+	tot, t := 0, 0
+	for _, e := range customers {
+		a, b := e[0], e[1]
+		t = max(t, a) + b
+		tot += t - a
+	}
+	return float64(tot) / float64(len(customers))
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
 }
 ```
 

solution/1700-1799/1701.Average Waiting Time/README_EN.md

@@ -59,29 +59,69 @@ So the average waiting time = (2 + 6 + 4 + 1) / 4 = 3.25.
 ```python
 class Solution:
     def averageWaitingTime(self, customers: List[List[int]]) -> float:
-        f = total_waiting_time = 0
-        for arrival, time in customers:
-            f = max(arrival, f) + time
-            total_waiting_time += f - arrival
-        return total_waiting_time / len(customers)
+        tot = t = 0
+        for a, b in customers:
+            t = max(t, a) + b
+            tot += t - a
+        return tot / len(customers)
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public double averageWaitingTime(int[][] customers) {
-        int f = 0;
-        double totalWaitingTime = 0;
-        for (int[] customer : customers) {
-            f = Math.max(f, customer[0]) + customer[1];
-            totalWaitingTime += (f - customer[0]);
+        double tot = 0;
+        int t = 0;
+        for (var e : customers) {
+            int a = e[0], b = e[1];
+            t = Math.max(t, a) + b;
+            tot += t - a;
         }
-        return totalWaitingTime / customers.length;
+        return tot / customers.length;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    double averageWaitingTime(vector<vector<int>>& customers) {
+        double tot = 0;
+        int t = 0;
+        for (auto& e : customers) {
+            int a = e[0], b = e[1];
+            t = max(t, a) + b;
+            tot += t - a;
+        }
+        return tot / customers.size();
+    }
+};
+```
+
+### **Go**
+
+```go
+func averageWaitingTime(customers [][]int) float64 {
+	tot, t := 0, 0
+	for _, e := range customers {
+		a, b := e[0], e[1]
+		t = max(t, a) + b
+		tot += t - a
+	}
+	return float64(tot) / float64(len(customers))
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```

solution/1700-1799/1701.Average Waiting Time/Solution.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    double averageWaitingTime(vector<vector<int>>& customers) {
+        double tot = 0;
+        int t = 0;
+        for (auto& e : customers) {
+            int a = e[0], b = e[1];
+            t = max(t, a) + b;
+            tot += t - a;
+        }
+        return tot / customers.size();
+    }
+};

solution/1700-1799/1701.Average Waiting Time/Solution.go

@@ -0,0 +1,16 @@
+func averageWaitingTime(customers [][]int) float64 {
+	tot, t := 0, 0
+	for _, e := range customers {
+		a, b := e[0], e[1]
+		t = max(t, a) + b
+		tot += t - a
+	}
+	return float64(tot) / float64(len(customers))
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

solution/1700-1799/1701.Average Waiting Time/Solution.java

@@ -1,11 +1,12 @@
 class Solution {
     public double averageWaitingTime(int[][] customers) {
-        int f = 0;
-        double totalWaitingTime = 0;
-        for (int[] customer : customers) {
-            f = Math.max(f, customer[0]) + customer[1];
-            totalWaitingTime += (f - customer[0]);
+        double tot = 0;
+        int t = 0;
+        for (var e : customers) {
+            int a = e[0], b = e[1];
+            t = Math.max(t, a) + b;
+            tot += t - a;
         }
-        return totalWaitingTime / customers.length;
+        return tot / customers.length;
     }
 }

solution/1700-1799/1701.Average Waiting Time/Solution.py

@@ -1,7 +1,7 @@
 class Solution:
     def averageWaitingTime(self, customers: List[List[int]]) -> float:
-        f = total_waiting_time = 0
-        for arrival, time in customers:
-            f = max(arrival, f) + time
-            total_waiting_time += f - arrival
-        return total_waiting_time / len(customers)
+        tot = t = 0
+        for a, b in customers:
+            t = max(t, a) + b
+            tot += t - a
+        return tot / len(customers)