LeetCode 45. Jump Game II Rust

Author: raul-sauco

README.md

@@ -52,7 +52,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 | [41. First Missing Positive][lc41]                                             | 🔴 Hard    | [![python](res/py.png)][lc41py]                                                              |
 | [42. Trapping Rain Water][lc42]                                                | 🔴 Hard    | [![python](res/py.png)][lc42py]                                                              |
 | [43. Multiply Strings][lc43]                                                   | 🟠 Medium  | [![python](res/py.png)][lc43py]                                                              |
-| [45. Jump Game II][lc45]                                                       | 🟠 Medium  | [![python](res/py.png)][lc45py]                                                              |
+| [45. Jump Game II][lc45]                                                       | 🟠 Medium  | [![python](res/py.png)][lc45py] [![rust](res/rs.png)][lc45rs]                                |
 | [46. Permutations][lc46]                                                       | 🟠 Medium  | [![python](res/py.png)][lc46py]                                                              |
 | [48. Rotate Image][lc48]                                                       | 🟠 Medium  | [![python](res/py.png)][lc48py]                                                              |
 | [49. Group Anagrams][lc49]                                                     | 🟠 Medium  | [![python](res/py.png)][lc49py]                                                              |
@@ -489,6 +489,7 @@ Solutions to LeetCode problems. The first column links to the problem in LeetCod
 [lc43py]: leetcode/multiply-strings.py
 [lc45]: https://leetcode.com/problems/jump-game-ii/
 [lc45py]: leetcode/jump-game-ii.py
+[lc45rs]: leetcode/jump-game-ii.rs
 [lc46]: https://leetcode.com/problems/permutations/
 [lc46py]: leetcode/permutations.py
 [lc48]: https://leetcode.com/problems/rotate-image/

leetcode/jump-game-ii.py

@@ -177,6 +177,7 @@ def test():
         Greedy,
     ]
     tests = [
+        [[0], 0],
         [[2, 3, 1, 1, 4], 2],
         [[2, 3, 0, 1, 4], 2],
         [[2, 3, 0, 1, 4, 0, 0, 0, 2, 8, 7, 3], 5],

leetcode/jump-game-ii.rs

@@ -0,0 +1,56 @@
+// 45. Jump Game II
+// 🟠 Medium
+//
+// https://leetcode.com/problems/jump-game-ii/
+//
+// Tags: Array - Dynamic Programming - Greedy
+
+struct Solution;
+impl Solution {
+    // Visit each element of the array but do it in groups, we can see it as
+    // treating each group as a level and the algorithm as BFS. For each
+    // level, keep track of the farthest position we could jump to from this
+    // level. When we get to the end of the level, add one to the number of
+    // jumps that we have taken, and update the current level by updating the
+    // last element we can explore to match the farthest element we can
+    // reach from this level.
+    // The algorithm repeatedly calculates the farthest point we can reach
+    // from any of the positions that we can reach given the current number
+    // of jumps, then "jump" once more and continue calculating. Each element
+    // is only explored once.
+    //
+    // Time complexity: O(n) - Each element is visited once.
+    // Space complexity: O(1) - Constant space.
+    //
+    // Runtime 2 ms Beats 80%
+    // Memory 2.1 MB Beats 71.3%
+    pub fn jump(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut jumps = 0;
+        let mut reach = 0;
+        let mut next_reach = 0;
+        for i in 0..n - 1 {
+            let current_jump = i + nums[i] as usize;
+            if current_jump > next_reach {
+                next_reach = current_jump;
+            }
+            if next_reach >= n - 1 {
+                return 1 + jumps as i32;
+            }
+            if i == reach {
+                jumps += 1;
+                reach = next_reach;
+            }
+        }
+        jumps as i32
+    }
+}
+
+// Tests.
+fn main() {
+    assert_eq!(Solution::jump(vec![0]), 0);
+    assert_eq!(Solution::jump(vec![2, 3, 1, 1, 4]), 2);
+    assert_eq!(Solution::jump(vec![2, 3, 0, 1, 4]), 2);
+    assert_eq!(Solution::jump(vec![2, 3, 0, 1, 4, 0, 0, 0, 2, 8, 7, 3]), 5);
+    println!("All tests passed!")
+}