<p>You are given a <strong>0-indexed</strong> array of integers <code>nums</code> of length <code>n</code>. You are initially positioned at <code>nums[0]</code>.</p>

<p>Each element <code>nums[i]</code> represents the maximum length of a forward jump from index <code>i</code>. In other words, if you are at <code>nums[i]</code>, you can jump to any <code>nums[i + j]</code> where:</p>

<ul>
	<li><code>0 &lt;= j &lt;= nums[i]</code> and</li>
	<li><code>i + j &lt; n</code></li>
</ul>

<p>Return <em>the minimum number of jumps to reach </em><code>nums[n - 1]</code>. The test cases are generated such that you can reach <code>nums[n - 1]</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [2,3,1,1,4]
<strong>Output:</strong> 2
<strong>Explanation:</strong> 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.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [2,3,0,1,4]
<strong>Output:</strong> 2
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>4</sup></code></li>
	<li><code>0 &lt;= nums[i] &lt;= 1000</code></li>
	<li>It&#39;s guaranteed that you can reach <code>nums[n - 1]</code>.</li>
</ul>

class Solution {
public:
    // int dp_jump(vector<int>& memo, vector<int>& nums, int index){
    //     if (index >= size(nums)-1){
    //         return 0;
    //     }
    //     if (memo[index] != 1001) {
    //         return memo[index];
    //     }
    //     for (int i = 1; i <= nums[index]; i++) {
    //         memo[index] = min(memo[index],dp_jump(memo,nums, index + i) + 1);
    //     }
    //     return memo[index];
    // }
    // int jump(vector<int>& nums) {
    //     vector<int> memo(size(nums),1001);
    //     return dp_jump(memo, nums, 0);
    // }
    int jump(vector<int>& nums) {
        vector<int> dp(size(nums), 10001); 
        return solve(nums, dp, 0);
    }
    int solve(vector<int>& nums, vector<int>& dp, int pos) {
        if(pos >= size(nums) - 1) return 0;    
        if(dp[pos] != 10001) return dp[pos];    
        for(int j = 1; j <= nums[pos]; j++)
            dp[pos] = min(dp[pos], 1 + solve(nums, dp, pos + j));        
        return dp[pos];
    }
};
20600