feat: add solutions to lc problem: No.1883 (doocs#1636)

No.1883.Minimum Skips to Arrive at Meeting On Time

Author: yanglbme

solution/1800-1899/1883.Minimum Skips to Arrive at Meeting On Time/README.md

@@ -69,16 +69,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“动态规划”实现。
+**方法一：动态规划**
 
-定义 `dp[i][j]` 表示前 i 段道路，跳过了 j 次的最短路程（耗时也一样）。
+我们定义 $f[i][j]$ 表示考虑前 $i$ 条道路，恰好跳过 $j$ 次休息时间的最短用时。初始时 $f[0][0]=0$，其余 $f[i][j]=\infty$。
 
-考虑最后一段道路 `dist[i - 1]` 是否跳过：
+由于我们可以选择跳过或者不跳过第 $i$ 条道路的休息时间，因此我们可以列出状态转移方程：
 
--   若没有跳过，那么 `dp[i][j] = ⌈dp[i - 1][j] + dist[i - 1] / speed⌉`
--   若跳过，那么 `dp[i][j] = dp[i - 1][j - 1] + dist[i - 1] / speed`
+$$
+f[i][j]=\min\left\{\begin{aligned} \lceil f[i-1][j]+\frac{d_i}{s}\rceil & \text{不跳过第 $i$ 条道路的休息时间} \\ f[i-1][j-1]+\frac{d_i}{s} & \text{跳过第 $i$ 条道路的休息时间} \end{aligned}\right.
+$$
 
-综合两种情况，`dp[i][j] = min{⌈dp[i - 1][j] + dist[i - 1] / speed⌉, dp[i - 1][j - 1] + dist[i - 1] / speed}`。
+其中 $\lceil x\rceil$ 表示将 $x$ 向上取整。需要注意的是，由于我们需要保证恰好跳过 $j$ 次休息时间，因此我们必须有 $j\le i$；另外，如果 $j=0$，不能跳过任何休息时间。
+
+由于浮点数运算以及向上取整运算可能会带来精度误差，因此我们引入一个常量 $eps = 10^{-8}$ 表示一个极小的正实数，在浮点数取整前先减去 $eps$，最后在比较 $f[n][j]$ 和 $hoursBefore$ 时，需要加上 $eps$。
+
+时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是道路的数量。
 
 <!-- tabs:start -->
 
@@ -90,22 +95,36 @@
 class Solution:
     def minSkips(self, dist: List[int], speed: int, hoursBefore: int) -> int:
         n = len(dist)
-        dp = [[inf] * (n + 1) for _ in range(n + 1)]
-        dp[0][0] = 0
-        for i in range(1, n + 1):
+        f = [[inf] * (n + 1) for _ in range(n + 1)]
+        f[0][0] = 0
+        eps = 1e-8
+        for i, x in enumerate(dist, 1):
+            for j in range(i + 1):
+                if j < i:
+                    f[i][j] = min(f[i][j], ceil(f[i - 1][j] + x / speed - eps))
+                if j:
+                    f[i][j] = min(f[i][j], f[i - 1][j - 1] + x / speed)
+        for j in range(n + 1):
+            if f[n][j] <= hoursBefore + eps:
+                return j
+        return -1
+```
+
+```python
+class Solution:
+    def minSkips(self, dist: List[int], speed: int, hoursBefore: int) -> int:
+        n = len(dist)
+        f = [[inf] * (n + 1) for _ in range(n + 1)]
+        f[0][0] = 0
+        for i, x in enumerate(dist, 1):
             for j in range(i + 1):
-                if i != j:
-                    # 没有跳过
-                    dp[i][j] = min(
-                        dp[i][j],
-                        ((dp[i - 1][j] + dist[i - 1] - 1) // speed + 1) * speed,
-                    )
-                if j > 0:
-                    # 跳过
-                    dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + dist[i - 1])
-        for i in range(n + 1):
-            if dp[n][i] <= hoursBefore * speed:
-                return i
+                if j < i:
+                    f[i][j] = min(f[i][j], ((f[i - 1][j] + x - 1) // speed + 1) * speed)
+                if j:
+                    f[i][j] = min(f[i][j], f[i - 1][j - 1] + x)
+        for j in range(n + 1):
+            if f[n][j] <= hoursBefore * speed:
+                return j
         return -1
 ```
 
@@ -117,36 +136,123 @@ class Solution:
 class Solution {
     public int minSkips(int[] dist, int speed, int hoursBefore) {
         int n = dist.length;
-        int[][] dp = new int[n + 1][n + 1];
-        for (int i = 0; i <= n; ++i) {
-            for (int j = 0; j <= n; ++j) {
-                dp[i][j] = Integer.MAX_VALUE;
-            }
+        double[][] f = new double[n + 1][n + 1];
+        for (int i = 0; i <= n; i++) {
+            Arrays.fill(f[i], 1e20);
         }
-        dp[0][0] = 0;
+        f[0][0] = 0;
+        double eps = 1e-8;
         for (int i = 1; i <= n; ++i) {
             for (int j = 0; j <= i; ++j) {
-                if (i != j) {
-                    // 没有跳过
-                    dp[i][j] = Math.min(
-                        dp[i][j], ((dp[i - 1][j] + dist[i - 1] - 1) / speed + 1) * speed);
+                if (j < i) {
+                    f[i][j] = Math.min(
+                        f[i][j], Math.ceil(f[i - 1][j]) + 1.0 * dist[i - 1] / speed - eps);
                 }
                 if (j > 0) {
-                    // 跳过
-                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1] + dist[i - 1]);
+                    f[i][j] = Math.min(f[i][j], f[i - 1][j - 1] + 1.0 * dist[i - 1] / speed);
                 }
             }
         }
-        for (int i = 0; i <= n; ++i) {
-            if (dp[n][i] <= hoursBefore * speed) {
-                return i;
+        for (int j = 0; j <= n; ++j) {
+            if (f[n][j] <= hoursBefore + eps) {
+                return j;
             }
         }
         return -1;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int minSkips(vector<int>& dist, int speed, int hoursBefore) {
+        int n = dist.size();
+        vector<vector<double>> f(n + 1, vector<double>(n + 1, 1e20));
+        f[0][0] = 0;
+        double eps = 1e-8;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j <= i; ++j) {
+                if (j < i) {
+                    f[i][j] = min(f[i][j], ceil(f[i - 1][j] + dist[i - 1] * 1.0 / speed - eps));
+                }
+                if (j) {
+                    f[i][j] = min(f[i][j], f[i - 1][j - 1] + dist[i - 1] * 1.0 / speed);
+                }
+            }
+        }
+        for (int j = 0; j <= n; ++j) {
+            if (f[n][j] <= hoursBefore + eps) {
+                return j;
+            }
+        }
+        return -1;
+    }
+};
+```
+
+### **Go**
+
+```go
+func minSkips(dist []int, speed int, hoursBefore int) int {
+	n := len(dist)
+	f := make([][]float64, n+1)
+	for i := range f {
+		f[i] = make([]float64, n+1)
+		for j := range f[i] {
+			f[i][j] = 1e20
+		}
+	}
+	f[0][0] = 0
+	eps := 1e-8
+	for i := 1; i <= n; i++ {
+		for j := 0; j <= i; j++ {
+			if j < i {
+				f[i][j] = math.Min(f[i][j], math.Ceil(f[i-1][j]+float64(dist[i-1])/float64(speed)-eps))
+			}
+			if j > 0 {
+				f[i][j] = math.Min(f[i][j], f[i-1][j-1]+float64(dist[i-1])/float64(speed))
+			}
+		}
+	}
+	for j := 0; j <= n; j++ {
+		if f[n][j] <= float64(hoursBefore) {
+			return j
+		}
+	}
+	return -1
+}
+```
+
+### **TypeScript**
+
+```ts
+function minSkips(dist: number[], speed: number, hoursBefore: number): number {
+    const n = dist.length;
+    const f = Array.from({ length: n + 1 }, () => Array.from({ length: n + 1 }, () => Infinity));
+    f[0][0] = 0;
+    const eps = 1e-8;
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 0; j <= i; ++j) {
+            if (j < i) {
+                f[i][j] = Math.min(f[i][j], Math.ceil(f[i - 1][j] + dist[i - 1] / speed - eps));
+            }
+            if (j) {
+                f[i][j] = Math.min(f[i][j], f[i - 1][j - 1] + dist[i - 1] / speed);
+            }
+        }
+    }
+    for (let j = 0; j <= n; ++j) {
+        if (f[n][j] <= hoursBefore + eps) {
+            return j;
+        }
+    }
+    return -1;
+}
+```
+
 ### **...**
 
 ```