ISRO CS 2020 - Question 5

ISRO CS 2020 Question 5 is a popular coding problem that is often used in technical interviews. As a programmer, it is important to be familiar with this problem and how to solve it efficiently.

Problem Statement

The problem statement is as follows:

You are given an array of integers, where each element represents the maximum number of steps that can be jumped going forward from that element. Write a function to return the minimum number of jumps you must take in order to get from the start to the end of the array. If it is impossible to reach the end, return -1.

Example

For example, given [6, 2, 4, 0, 5, 1, 1, 4, 2, 9], you should return 2, as the optimal solution involves jumping from 6 to 5, and then from 5 to 9.

Approach

To solve this problem, we can use the Breadth-First Search (BFS) algorithm. We start by assuming that the first element of the array is the starting point. We then add all the reachable elements from this starting point to a queue along with the number of steps required to reach them. We keep on traversing this queue until we reach the end of the array or until we exhaust all possible paths.

We keep a track of the steps required to reach each element of the array. We add 1 to the number of steps required to reach the next element from the current element. We also keep a track of the farthest index that we can reach from the current element.

When we reach the end of the array or when we are unable to find a path to the end, we return -1.

Code

Here is the implementation of the approach in Python:

def minimum_jumps(arr):
    n = len(arr)
    steps = [float('inf')] * n
    steps[0] = 0
    farthest = 0

    for i in range(n):
        for j in range(i + 1, min(n, i + arr[i] + 1)):
            steps[j] = min(steps[j], steps[i] + 1)
            if j == n - 1:
                return steps[n - 1]
        farthest = max(farthest, i + arr[i])
        if farthest <= i:
            return -1

    return -1

Time Complexity

The time complexity of this approach is O(n^2), where n is the length of the array. However, in practice, the actual time taken would be much less than this, as we are not exploring all possible paths. We are stopping when we reach the end of the array or when we are unable to find a path to the end.