<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>

# from collections import deque
# class Solution:
#     def jump(self, nums: List[int]) -> int:
#         if len(nums)<=1:
#             return 0

#         nJumps = 0

#         q = deque([0])
#         visited = set([0])
#         while q:
#             i = q.popleft()
#             nJumps += 1
#             for j in range(1, nums[i]+1):
#                 if i+j == len(nums)-1:
#                     return nJumps
#                 if i+j not in visited:
#                     q.append(i+j)
#                     visited.add(i+j)

#         return nJumps



from collections import deque
class Solution:
    def jump(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return 0

        nJumps = 0
        q = deque([0])
        visited = set([0])  # To avoid revisiting the same index
        
        while q:
            nJumps += 1
            size = len(q)  # Process all nodes at the current level
            for _ in range(size):
                i = q.popleft()
                for j in range(1, nums[i] + 1):
                    next_idx = i + j
                    if next_idx >= len(nums) - 1:  # If we can reach the end
                        return nJumps
                    if next_idx not in visited:
                        visited.add(next_idx)  # Mark as visited
                        q.append(next_idx)
18400