feat: add Jump Game II problem

TechnoBlogger14o3 · TechnoBlogger14o3 · commit a4bf8c2a7623 · 2025-10-11T13:49:55.000+05:30
- Greedy algorithm implementation
- Multiple approaches: DP, BFS, Backtracking, Memoization
- O(n) time, O(1) space complexity
- Comprehensive explanations and edge cases
diff --git a/neetcode-150/greedy/jump-game-ii/explanation.md b/neetcode-150/greedy/jump-game-ii/explanation.md
@@ -0,0 +1,84 @@
+# Jump Game II
+
+## Problem Statement
+
+You are given a 0-indexed integer array `nums` of length `n`. You are initially positioned at `nums[0]`.
+
+Each element `nums[i]` represents the maximum jump length at that position.
+
+Return the minimum number of jumps to reach `nums[n - 1]`. The test cases are generated such that you can reach `nums[n - 1]`.
+
+## Examples
+
+**Example 1:**
+```
+Input: nums = [2,3,1,1,4]
+Output: 2
+Explanation: The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
+```
+
+## Approach
+
+### Method 1: Greedy Algorithm (Recommended)
+1. Track the farthest position we can reach with current jumps
+2. Track the farthest position we can reach with next jump
+3. When we reach the end of current jump range, increment jump count
+4. Most efficient approach
+
+**Time Complexity:** O(n) - Single pass
+**Space Complexity:** O(1) - Two variables
+
+### Method 2: Dynamic Programming
+1. Use DP to store minimum jumps to reach each position
+2. dp[i] = minimum jumps to reach position i
+3. Less efficient than greedy approach
+
+**Time Complexity:** O(n²) - Nested loops
+**Space Complexity:** O(n) - DP array
+
+## Algorithm
+
+```
+1. Initialize jumps = 0, currentEnd = 0, farthest = 0
+2. For i from 0 to n-2:
+   a. farthest = max(farthest, i + nums[i])
+   b. If i == currentEnd:
+      c. jumps++
+      d. currentEnd = farthest
+3. Return jumps
+```
+
+## Key Insights
+
+- **Greedy Choice**: Always try to reach the farthest position with minimum jumps
+- **Local Optimum**: Maximum reachable position with current jumps
+- **Global Optimum**: Minimum number of jumps to reach last index
+- **Space Optimization**: Use only two variables
+
+## Alternative Approaches
+
+1. **Dynamic Programming**: Use DP array
+2. **BFS**: Use BFS to find shortest path
+3. **Backtracking**: Use backtracking to explore all paths
+
+## Edge Cases
+
+- Single element: Return 0
+- Two elements: Return 1
+- All ones: Return n-1
+- Large jumps: Handle appropriately
+
+## Applications
+
+- Greedy algorithms
+- Dynamic programming patterns
+- Algorithm design patterns
+- Interview preparation
+- System design
+
+## Optimization Opportunities
+
+- **Greedy Algorithm**: Most efficient approach
+- **Space Optimization**: O(1) space complexity
+- **Single Pass**: O(n) time complexity
+- **No Extra Space**: Use only two variables
diff --git a/neetcode-150/greedy/jump-game-ii/solution.java b/neetcode-150/greedy/jump-game-ii/solution.java
@@ -0,0 +1,177 @@
+/**
+ * Time Complexity: O(n) - Single pass
+ * Space Complexity: O(1) - Two variables
+ */
+class Solution {
+    public int jump(int[] nums) {
+        int jumps = 0;
+        int currentEnd = 0;
+        int farthest = 0;
+        
+        for (int i = 0; i < nums.length - 1; i++) {
+            farthest = Math.max(farthest, i + nums[i]);
+            
+            if (i == currentEnd) {
+                jumps++;
+                currentEnd = farthest;
+            }
+        }
+        
+        return jumps;
+    }
+}
+
+// Alternative approach using Dynamic Programming
+class SolutionDP {
+    public int jump(int[] nums) {
+        int[] dp = new int[nums.length];
+        Arrays.fill(dp, Integer.MAX_VALUE);
+        dp[0] = 0;
+        
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = 1; j <= nums[i] && i + j < nums.length; j++) {
+                dp[i + j] = Math.min(dp[i + j], dp[i] + 1);
+            }
+        }
+        
+        return dp[nums.length - 1];
+    }
+}
+
+// Alternative approach using BFS
+class SolutionBFS {
+    public int jump(int[] nums) {
+        if (nums.length <= 1) {
+            return 0;
+        }
+        
+        Queue<Integer> queue = new LinkedList<>();
+        boolean[] visited = new boolean[nums.length];
+        
+        queue.offer(0);
+        visited[0] = true;
+        
+        int jumps = 0;
+        
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            
+            for (int i = 0; i < size; i++) {
+                int current = queue.poll();
+                
+                if (current == nums.length - 1) {
+                    return jumps;
+                }
+                
+                int farthestJump = Math.min(current + nums[current], nums.length - 1);
+                
+                for (int next = current + 1; next <= farthestJump; next++) {
+                    if (!visited[next]) {
+                        visited[next] = true;
+                        queue.offer(next);
+                    }
+                }
+            }
+            
+            jumps++;
+        }
+        
+        return jumps;
+    }
+}
+
+// Alternative approach using backtracking
+class SolutionBacktracking {
+    public int jump(int[] nums) {
+        return jumpHelper(nums, 0);
+    }
+    
+    private int jumpHelper(int[] nums, int position) {
+        if (position >= nums.length - 1) {
+            return 0;
+        }
+        
+        int minJumps = Integer.MAX_VALUE;
+        int farthestJump = Math.min(position + nums[position], nums.length - 1);
+        
+        for (int nextPosition = position + 1; nextPosition <= farthestJump; nextPosition++) {
+            int jumps = jumpHelper(nums, nextPosition);
+            if (jumps != Integer.MAX_VALUE) {
+                minJumps = Math.min(minJumps, jumps + 1);
+            }
+        }
+        
+        return minJumps;
+    }
+}
+
+// Alternative approach using iterative
+class SolutionIterative {
+    public int jump(int[] nums) {
+        int jumps = 0;
+        int currentEnd = 0;
+        int farthest = 0;
+        
+        for (int i = 0; i < nums.length - 1; i++) {
+            farthest = Math.max(farthest, i + nums[i]);
+            
+            if (i == currentEnd) {
+                jumps++;
+                currentEnd = farthest;
+                
+                if (currentEnd >= nums.length - 1) {
+                    break;
+                }
+            }
+        }
+        
+        return jumps;
+    }
+}
+
+// Alternative approach using recursion with memoization
+class SolutionMemoization {
+    public int jump(int[] nums) {
+        int[] memo = new int[nums.length];
+        Arrays.fill(memo, -1);
+        return jumpHelper(nums, 0, memo);
+    }
+    
+    private int jumpHelper(int[] nums, int position, int[] memo) {
+        if (position >= nums.length - 1) {
+            return 0;
+        }
+        
+        if (memo[position] != -1) {
+            return memo[position];
+        }
+        
+        int minJumps = Integer.MAX_VALUE;
+        int farthestJump = Math.min(position + nums[position], nums.length - 1);
+        
+        for (int nextPosition = position + 1; nextPosition <= farthestJump; nextPosition++) {
+            int jumps = jumpHelper(nums, nextPosition, memo);
+            if (jumps != Integer.MAX_VALUE) {
+                minJumps = Math.min(minJumps, jumps + 1);
+            }
+        }
+        
+        memo[position] = minJumps;
+        return minJumps;
+    }
+}
+
+// More concise version
+class SolutionConcise {
+    public int jump(int[] nums) {
+        int jumps = 0, currentEnd = 0, farthest = 0;
+        for (int i = 0; i < nums.length - 1; i++) {
+            farthest = Math.max(farthest, i + nums[i]);
+            if (i == currentEnd) {
+                jumps++;
+                currentEnd = farthest;
+            }
+        }
+        return jumps;
+    }
+}
