<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 jump(vector<int>& nums) {
        int size = static_cast<int>(nums.size());
        
        // table[num_steps] is the index of the first element, for which the end is reachable with, or -1
        // if not set yet.
        // 'num_step' steps.
        std::vector<int> stack(nums.size());
        int result;
        for(int i = size - 2; i >= 0; i--) {
            int target = size - 1;

            int num_steps = 1;
            for(int& stack_elem : stack) {
                if(i + nums[i] >= target) {
                    stack_elem = i;
                    result = num_steps;
                    break;
                } else {
                    target = stack_elem;
                    num_steps++;
                }
            }
        }
        
        std::vector<int> num_jumps(size, INT_MAX);
        num_jumps[0] = 0;
        for(int i = 0; i < size; i++) {
            int max_jump = std::min(i + nums[i] + 1, size);
            for(int j = i + 1; j < max_jump; j++) {
                num_jumps[j] = std::min(num_jumps[j], num_jumps[i] + 1);
            }
        }
        return num_jumps.back();
    }
};
20200