feat: add solutions to lc problem: No.1665

No.1665.Minimum Initial Energy to Finish Tasks

Author: yanglbme

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/README.md

@@ -91,9 +91,11 @@ $$
 E \geq \sum_{i=1}^{n} a_i + (m_n - a_n)
 $$
 
-其中 $\sum_{i=1}^{n} a_i$ 是固定不变的，要使得初始值能量值 $E$ 最小，我们需要让 $m_n - a_n$ 最小，即 $a_n-m_n$ 最大。因此，我们可以将任务按照 $a_n-m_n$ 从小到大排序，然后依次完成任务，算出所需要的初始能量值。
+其中 $\sum_{i=1}^{n} a_i$ 是固定不变的，要使得初始值能量值 $E$ 最小，我们需要让 $m_n - a_n$ 最小，即 $a_n-m_n$ 最大。
 
-时间复杂度 $O(n\times \log n)$。其中 $n$ 为任务数。
+因此，我们可以将任务按照 $a_i-m_i$ 从小到大排序。然后从前往后遍历任务，对于每个任务，如果当前能量值 $cur$ 小于 $m_i$，则需要增加能量值 $m_i - cur$，使得当前能量值刚好等于 $m_i$，然后再完成任务，更新 $cur = cur - a_i$。继续遍历，直到完成所有任务，即可得到初始所需的最少能量值。
+
+时间复杂度 $O(n\times \log n)$。其中 $n$ 为任务数。忽略排序的空间开销，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -104,12 +106,12 @@ $$
 ```python
 class Solution:
     def minimumEffort(self, tasks: List[List[int]]) -> int:
-        ans = t = 0
+        ans = cur = 0
         for a, m in sorted(tasks, key=lambda x: x[0] - x[1]):
-            if t < m:
-                ans += m - t
-                t = m
-            t -= a
+            if cur < m:
+                ans += m - cur
+                cur = m
+            cur -= a
         return ans
 ```
 
@@ -120,14 +122,15 @@ class Solution:
 ```java
 class Solution {
     public int minimumEffort(int[][] tasks) {
-        Arrays.sort(tasks, (a, b) -> a[0] - b[0] - a[1] + b[1]);
-        int ans = 0, t = 0;
-        for (var e : tasks) {
-            if (t < e[1]) {
-                ans += e[1] - t;
-                t = e[1];
+        Arrays.sort(tasks, (a, b) -> a[0] - b[0] - (a[1] - b[1]));
+        int ans = 0, cur = 0;
+        for (var task : tasks) {
+            int a = task[0], m = task[1];
+            if (cur < m) {
+                ans += m - cur;
+                cur = m;
             }
-            t -= e[0];
+            cur -= a;
         }
         return ans;
     }
@@ -140,14 +143,15 @@ class Solution {
 class Solution {
 public:
     int minimumEffort(vector<vector<int>>& tasks) {
-        sort(tasks.begin(), tasks.end(), [&](auto& a, auto& b) -> bool { return a[0] - a[1] < b[0] - b[1]; });
-        int ans = 0, t = 0;
-        for (auto& e : tasks) {
-            if (t < e[1]) {
-                ans += e[1] - t;
-                t = e[1];
+        sort(tasks.begin(), tasks.end(), [&](const auto& a, const auto& b) { return a[0] - a[1] < b[0] - b[1]; });
+        int ans = 0, cur = 0;
+        for (auto& task : tasks) {
+            int a = task[0], m = task[1];
+            if (cur < m) {
+                ans += m - cur;
+                cur = m;
             }
-            t -= e[0];
+            cur -= a;
         }
         return ans;
     }
@@ -157,17 +161,36 @@ public:
 ### **Go**
 
 ```go
-func minimumEffort(tasks [][]int) int {
+func minimumEffort(tasks [][]int) (ans int) {
 	sort.Slice(tasks, func(i, j int) bool { return tasks[i][0]-tasks[i][1] < tasks[j][0]-tasks[j][1] })
-	var ans, t int
-	for _, e := range tasks {
-		if t < e[1] {
-			ans += e[1] - t
-			t = e[1]
+	cur := 0
+	for _, task := range tasks {
+		a, m := task[0], task[1]
+		if cur < m {
+			ans += m - cur
+			cur = m
 		}
-		t -= e[0]
+		cur -= a
 	}
-	return ans
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function minimumEffort(tasks: number[][]): number {
+    tasks.sort((a, b) => a[0] - a[1] - (b[0] - b[1]));
+    let ans = 0;
+    let cur = 0;
+    for (const [a, m] of tasks) {
+        if (cur < m) {
+            ans += m - cur;
+            cur = m;
+        }
+        cur -= a;
+    }
+    return ans;
 }
 ```
 

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/README_EN.md

@@ -75,12 +75,12 @@ Starting with 27 energy, we finish the tasks in the following order:
 ```python
 class Solution:
     def minimumEffort(self, tasks: List[List[int]]) -> int:
-        ans = t = 0
+        ans = cur = 0
         for a, m in sorted(tasks, key=lambda x: x[0] - x[1]):
-            if t < m:
-                ans += m - t
-                t = m
-            t -= a
+            if cur < m:
+                ans += m - cur
+                cur = m
+            cur -= a
         return ans
 ```
 
@@ -89,14 +89,15 @@ class Solution:
 ```java
 class Solution {
     public int minimumEffort(int[][] tasks) {
-        Arrays.sort(tasks, (a, b) -> a[0] - b[0] - a[1] + b[1]);
-        int ans = 0, t = 0;
-        for (var e : tasks) {
-            if (t < e[1]) {
-                ans += e[1] - t;
-                t = e[1];
+        Arrays.sort(tasks, (a, b) -> a[0] - b[0] - (a[1] - b[1]));
+        int ans = 0, cur = 0;
+        for (var task : tasks) {
+            int a = task[0], m = task[1];
+            if (cur < m) {
+                ans += m - cur;
+                cur = m;
             }
-            t -= e[0];
+            cur -= a;
         }
         return ans;
     }
@@ -109,14 +110,15 @@ class Solution {
 class Solution {
 public:
     int minimumEffort(vector<vector<int>>& tasks) {
-        sort(tasks.begin(), tasks.end(), [&](auto& a, auto& b) -> bool { return a[0] - a[1] < b[0] - b[1]; });
-        int ans = 0, t = 0;
-        for (auto& e : tasks) {
-            if (t < e[1]) {
-                ans += e[1] - t;
-                t = e[1];
+        sort(tasks.begin(), tasks.end(), [&](const auto& a, const auto& b) { return a[0] - a[1] < b[0] - b[1]; });
+        int ans = 0, cur = 0;
+        for (auto& task : tasks) {
+            int a = task[0], m = task[1];
+            if (cur < m) {
+                ans += m - cur;
+                cur = m;
             }
-            t -= e[0];
+            cur -= a;
         }
         return ans;
     }
@@ -126,17 +128,36 @@ public:
 ### **Go**
 
 ```go
-func minimumEffort(tasks [][]int) int {
+func minimumEffort(tasks [][]int) (ans int) {
 	sort.Slice(tasks, func(i, j int) bool { return tasks[i][0]-tasks[i][1] < tasks[j][0]-tasks[j][1] })
-	var ans, t int
-	for _, e := range tasks {
-		if t < e[1] {
-			ans += e[1] - t
-			t = e[1]
+	cur := 0
+	for _, task := range tasks {
+		a, m := task[0], task[1]
+		if cur < m {
+			ans += m - cur
+			cur = m
 		}
-		t -= e[0]
+		cur -= a
 	}
-	return ans
+	return
+}
+```
+
+### **TypeScript**
+
+```ts
+function minimumEffort(tasks: number[][]): number {
+    tasks.sort((a, b) => a[0] - a[1] - (b[0] - b[1]));
+    let ans = 0;
+    let cur = 0;
+    for (const [a, m] of tasks) {
+        if (cur < m) {
+            ans += m - cur;
+            cur = m;
+        }
+        cur -= a;
+    }
+    return ans;
 }
 ```
 

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/Solution.cpp

@@ -1,14 +1,15 @@
 class Solution {
 public:
     int minimumEffort(vector<vector<int>>& tasks) {
-        sort(tasks.begin(), tasks.end(), [&](auto& a, auto& b) -> bool { return a[0] - a[1] < b[0] - b[1]; });
-        int ans = 0, t = 0;
-        for (auto& e : tasks) {
-            if (t < e[1]) {
-                ans += e[1] - t;
-                t = e[1];
+        sort(tasks.begin(), tasks.end(), [&](const auto& a, const auto& b) { return a[0] - a[1] < b[0] - b[1]; });
+        int ans = 0, cur = 0;
+        for (auto& task : tasks) {
+            int a = task[0], m = task[1];
+            if (cur < m) {
+                ans += m - cur;
+                cur = m;
             }
-            t -= e[0];
+            cur -= a;
         }
         return ans;
     }

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/Solution.go

@@ -1,12 +1,13 @@
-func minimumEffort(tasks [][]int) int {
+func minimumEffort(tasks [][]int) (ans int) {
 	sort.Slice(tasks, func(i, j int) bool { return tasks[i][0]-tasks[i][1] < tasks[j][0]-tasks[j][1] })
-	var ans, t int
-	for _, e := range tasks {
-		if t < e[1] {
-			ans += e[1] - t
-			t = e[1]
+	cur := 0
+	for _, task := range tasks {
+		a, m := task[0], task[1]
+		if cur < m {
+			ans += m - cur
+			cur = m
 		}
-		t -= e[0]
+		cur -= a
 	}
-	return ans
+	return
 }

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/Solution.java

@@ -1,13 +1,14 @@
 class Solution {
     public int minimumEffort(int[][] tasks) {
-        Arrays.sort(tasks, (a, b) -> a[0] - b[0] - a[1] + b[1]);
-        int ans = 0, t = 0;
-        for (var e : tasks) {
-            if (t < e[1]) {
-                ans += e[1] - t;
-                t = e[1];
+        Arrays.sort(tasks, (a, b) -> a[0] - b[0] - (a[1] - b[1]));
+        int ans = 0, cur = 0;
+        for (var task : tasks) {
+            int a = task[0], m = task[1];
+            if (cur < m) {
+                ans += m - cur;
+                cur = m;
             }
-            t -= e[0];
+            cur -= a;
         }
         return ans;
     }

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/Solution.py

@@ -1,9 +1,9 @@
 class Solution:
     def minimumEffort(self, tasks: List[List[int]]) -> int:
-        ans = t = 0
+        ans = cur = 0
         for a, m in sorted(tasks, key=lambda x: x[0] - x[1]):
-            if t < m:
-                ans += m - t
-                t = m
-            t -= a
+            if cur < m:
+                ans += m - cur
+                cur = m
+            cur -= a
         return ans

solution/1600-1699/1665.Minimum Initial Energy to Finish Tasks/Solution.ts

@@ -0,0 +1,13 @@
+function minimumEffort(tasks: number[][]): number {
+    tasks.sort((a, b) => a[0] - a[1] - (b[0] - b[1]));
+    let ans = 0;
+    let cur = 0;
+    for (const [a, m] of tasks) {
+        if (cur < m) {
+            ans += m - cur;
+            cur = m;
+        }
+        cur -= a;
+    }
+    return ans;
+}