Minimize the number of steps required to reach the end of the array | Set 2

Given an integer array arr[] of length N consisting of positive integers, the task is to minimize the number of steps required to reach the arr[N – 1] starting from arr[0]. At a given step if we are at index i we can go to index i – arr[i] or i + arr[i] given we have not visited those indexes before. Also, we cannot go outside the bounds of the array. Print -1 if there is no possible way.

Examples:

Input: arr[] = {1, 1, 1} 
Output: 2 
The path will be 0 -> 1 -> 2.
Input: arr[] = {2, 1} 
Output: -1  

Approach: We have already discussed a dynamic programming based approach in this article which has a time complexity of O(n * 2ⁿ). 
Here we’re going to discuss a BFS based solution:  

1. This problem can be visualized as a directed graph where i^th cell is connected with cells i + arr[i] and i – arr[i].
2. And the graph is un-weighted.

Due to the above, BFS can be used to find the shortest path between 0^th and the (N – 1)^th index. We will use the following algorithm:  

1. Push index 0 in a queue.
2. Push all the adjacent cells to 0 in the queue.
3. Repeat the above steps i.e. traverse all the elements in the queue individually again if they have not been visited/traversed before.
4. Repeat till we don’t reach the index N – 1.
5. The depth of this traversal will give the minimum steps required to reach the end.

Remember to mark a cell visited after it has been traversed. For this, we will use a boolean array.

Below is the implementation of the above approach:  

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the minimum steps
// required to reach the end
// of the given array
int minSteps(int arr[], int n)
{
    // Array to determine whether
    // a cell has been visited before
    bool v[n] = { 0 };

    // Queue for bfs
    queue<int> q;

    // Push the source i.e. index 0
    q.push(0);

    // Variable to store
    // the depth of search
    int depth = 0;

    // BFS algorithm
    while (q.size() != 0) {

        // Current queue size
        int x = q.size();
        while (x--) {

            // Top-most element of queue
            int i = q.front();
            q.pop();

            // Base case
            if (v[i])
                continue;

            // If we reach the destination
            // i.e. index (n - 1)
            if (i == n - 1)
                return depth;

            // Marking the cell visited
            v[i] = 1;

            // Pushing the adjacent nodes
            // i.e. indices reachable
            // from the current index
            if (i + arr[i] < n)
                q.push(i + arr[i]);
            if (i - arr[i] >= 0)
                q.push(i - arr[i]);
        }
        depth++;
    }

    return -1;
}

// Driver code
int main()
{
    int arr[] = { 1, 1, 1, 1, 1, 1 };
    int n = sizeof(arr) / sizeof(int);

    cout << minSteps(arr, n);

    return 0;
}

Java

// Java implementation of the approach
import java.util.*;

class GFG
{

// Function to return the minimum steps
// required to reach the end
// of the given array
static int minSteps(int arr[], int n)
{
    // Array to determine whether
    // a cell has been visited before
    boolean[] v = new boolean[n];

    // Queue for bfs
    Queue<Integer> q = new LinkedList<>();

    // Push the source i.e. index 0
    q.add(0);

    // Variable to store
    // the depth of search
    int depth = 0;

    // BFS algorithm
    while (q.size() > 0)
    {

        // Current queue size
        int x = q.size();
        while (x-- > 0)
        {

            // Top-most element of queue
            int i = q.peek();
            q.poll();

            // Base case
            if (v[i])
                continue;

            // If we reach the destination
            // i.e. index (n - 1)
            if (i == n - 1)
                return depth;

            // Marking the cell visited
            v[i] = true;

            // Pushing the adjacent nodes
            // i.e. indices reachable
            // from the current index
            if (i + arr[i] < n)
                q.add(i + arr[i]);
            if (i - arr[i] >= 0)
                q.add(i - arr[i]);
        }
        depth++;
    }

    return -1;
}

// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 1, 1, 1, 1, 1 };
    int n = arr.length;
    System.out.println(minSteps(arr, n));
}
}

/* This code contributed by PrinciRaj1992 */

Python3

# Python 3 implementation of the approach

# Function to return the minimum steps
# required to reach the end
# of the given array
def minSteps(arr,n):

    # Array to determine whether
    # a cell has been visited before
    v = [0 for i in range(n)]

    # Queue for bfs
    q = []

    # Push the source i.e. index 0
    q.append(0)

    # Variable to store
    # the depth of search
    depth = 0

    # BFS algorithm
    while (len(q) != 0):
        # Current queue size
        x = len(q)
        while (x >= 1):
            # Top-most element of queue
            i = q[0]
            q.remove(i)

            x -= 1

            # Base case
            if (v[i]):
                continue;

            # If we reach the destination
            # i.e. index (n - 1)
            if (i == n - 1):
                return depth

            # Marking the cell visited
            v[i] = 1

            # Pushing the adjacent nodes
            # i.e. indices reachable
            # from the current index
            if (i + arr[i] < n):
                q.append(i + arr[i])
            if (i - arr[i] >= 0):
                q.append(i - arr[i])


        depth += 1

    return -1

# Driver code
if __name__ == '__main__':
    arr = [1, 1, 1, 1, 1, 1]
    n = len(arr)

    print(minSteps(arr, n))

# This code is contributed by
# Surendra_Gangwar

C#

// A C# implementation of the approach
using System;
using System.Collections.Generic;

class GFG
{

// Function to return the minimum steps
// required to reach the end
// of the given array
static int minSteps(int []arr, int n)
{
    // Array to determine whether
    // a cell has been visited before
    Boolean[] v = new Boolean[n];

    // Queue for bfs
    Queue<int> q = new Queue<int>();

    // Push the source i.e. index 0
    q.Enqueue(0);

    // Variable to store
    // the depth of search
    int depth = 0;

    // BFS algorithm
    while (q.Count > 0)
    {

        // Current queue size
        int x = q.Count;
        while (x-- > 0)
        {

            // Top-most element of queue
            int i = q.Peek();
            q.Dequeue();

            // Base case
            if (v[i])
                continue;

            // If we reach the destination
            // i.e. index (n - 1)
            if (i == n - 1)
                return depth;

            // Marking the cell visited
            v[i] = true;

            // Pushing the adjacent nodes
            // i.e. indices reachable
            // from the current index
            if (i + arr[i] < n)
                q.Enqueue(i + arr[i]);
            if (i - arr[i] >= 0)
                q.Enqueue(i - arr[i]);
        }
        depth++;
    }

    return -1;
}

// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 1, 1, 1, 1, 1 };
    int n = arr.Length;
    Console.WriteLine(minSteps(arr, n));
}
}

// This code contributed by Rajput-Ji

Javascript

<script>

// Javascript implementation of the approach

// Function to return the minimum steps
// required to reach the end
// of the given array
function minSteps(arr, n)
{
    // Array to determine whether
    // a cell has been visited before
    var v = Array(n).fill(0);

    // Queue for bfs
    var q = [];

    // Push the source i.e. index 0
    q.push(0);

    // Variable to store
    // the depth of search
    var depth = 0;

    // BFS algorithm
    while (q.length != 0) {

        // Current queue size
        var x = q.length;
        while (x--) {

            // Top-most element of queue
            var i = q[0];
            q.shift();

            // Base case
            if (v[i])
                continue;

            // If we reach the destination
            // i.e. index (n - 1)
            if (i == n - 1)
                return depth;

            // Marking the cell visited
            v[i] = 1;

            // Pushing the adjacent nodes
            // i.e. indices reachable
            // from the current index
            if (i + arr[i] < n)
                q.push(i + arr[i]);
            if (i - arr[i] >= 0)
                q.push(i - arr[i]);
        }
        depth++;
    }

    return -1;
}

// Driver code
var arr = [1, 1, 1, 1, 1, 1];
var n = arr.length;
document.write( minSteps(arr, n));


</script>

Output:

5

Time complexity: O(N)

Auxiliary Space: O(N)