Check if the end of the Array can be reached from a given position

09 Nov, 2021
Given an array arr[] of N positive integers and a number S, the task is to reach the end of the array from index S. We can only move from current index i to index (i + arr[i]) or (i – arr[i]). If there is a way to reach the end of the array then print “Yes” else print “No”.
Examples: 
Input: arr[] = {4, 1, 3, 2, 5}, S = 1 Output: Yes Explanation: initial position: arr[S] = arr[1] = 1. Jumps to reach the end: 1 -> 4 -> 5 Hence end has been reached. 
Input: arr[] = {2, 1, 4, 5}, S = 2 Output: No Explanation: initial position: arr[S] = arr[2] = 2. Possible Jumps to reach the end: 4 -> (index 7) or 4 -> (index -2) Since both are out of bounds, Hence end can’t be reached.  
Approach 1: This problem can be solved using Breadth First Search. Below are the steps:  
Consider start index S as the source node and insert it into the queue.
While the queue is not empty do the following: Pop the element from the top of the queue say temp.If temp is already visited or it is array out of bound index then, go to step 1.Else mark it as visited.Now if temp is the last index of the array, then print “Yes”.Else take two possible destinations from temp to (temp + arr[temp]), (temp – arr[temp]) and push it into the queue.
Pop the element from the top of the queue say temp.If temp is already visited or it is array out of bound index then, go to step 1.Else mark it as visited.Now if temp is the last index of the array, then print “Yes”.Else take two possible destinations from temp to (temp + arr[temp]), (temp – arr[temp]) and push it into the queue.
Pop the element from the top of the queue say temp.
If temp is already visited or it is array out of bound index then, go to step 1.
Else mark it as visited.
Now if temp is the last index of the array, then print “Yes”.
Else take two possible destinations from temp to (temp + arr[temp]), (temp – arr[temp]) and push it into the queue.
If the end of the array is not reached after the above steps then print “No”.
Below is the implementation of the above approach: 
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Function to check if we can reach to// the end of the arr[] with possible movesvoid solve(int arr[], int n, int start){     // Queue to perform BFS    queue<int> q;     // Initially all nodes(index)    // are not visited.    bool visited[n] = { false };     // Initially the end of    // the array is not reached    bool reached = false;     // Push start index in queue    q.push(start);     // Until queue becomes empty    while (!q.empty()) {         // Get the top element        int temp = q.front();         // Delete popped element        q.pop();         // If the index is already        // visited. No need to        // traverse it again.        if (visited[temp] == true)            continue;         // Mark temp as visited        // if not        visited[temp] = true;        if (temp == n - 1) {             // If reached at the end            // of the array then break            reached = true;            break;        }         // If temp + arr[temp] and        // temp - arr[temp] are in        // the index of array        if (temp + arr[temp] < n) {            q.push(temp + arr[temp]);        }         if (temp - arr[temp] >= 0) {            q.push(temp - arr[temp]);        }    }     // If reaches the end of the array,    // Print "Yes"    if (reached == true) {        cout << "Yes";    }     // Else print "No"    else {        cout << "No";    }} // Driver Codeint main(){    // Given array arr[]    int arr[] = { 4, 1, 3, 2, 5 };     // Starting index    int S = 1;    int N = sizeof(arr) / sizeof(arr[0]);     // Function Call    solve(arr, N, S);     return 0;}
// Java program for the above approachimport java.util.*; class GFG{ // Function to check if we can reach to// the end of the arr[] with possible movesstatic void solve(int arr[], int n, int start){     // Queue to perform BFS    Queue<Integer> q = new LinkedList<>();     // Initially all nodes(index)    // are not visited.    boolean []visited = new boolean[n];     // Initially the end of    // the array is not reached    boolean reached = false;     // Push start index in queue    q.add(start);     // Until queue becomes empty    while (!q.isEmpty())    {         // Get the top element        int temp = q.peek();         // Delete popped element        q.remove();         // If the index is already        // visited. No need to        // traverse it again.        if (visited[temp] == true)            continue;         // Mark temp as visited        // if not        visited[temp] = true;                 if (temp == n - 1)        {             // If reached at the end            // of the array then break            reached = true;            break;        }         // If temp + arr[temp] and        // temp - arr[temp] are in        // the index of array        if (temp + arr[temp] < n)        {            q.add(temp + arr[temp]);        }         if (temp - arr[temp] >= 0)        {            q.add(temp - arr[temp]);        }    }     // If reaches the end of the array,    // Print "Yes"    if (reached == true)    {        System.out.print("Yes");    }     // Else print "No"    else    {        System.out.print("No");    }} // Driver Codepublic static void main(String[] args){         // Given array arr[]    int arr[] = { 4, 1, 3, 2, 5 };     // Starting index    int S = 1;    int N = arr.length;     // Function call    solve(arr, N, S);}} // This code is contributed by gauravrajput1
# Python3 program for the above approachfrom queue import Queue  # Function to check if we can reach to# the end of the arr[] with possible movesdef solve(arr, n, start):      # Queue to perform BFS    q = Queue()      # Initially all nodes(index)    # are not visited.    visited = [False] * n        # Initially the end of    # the array is not reached    reached = False        # Push start index in queue    q.put(start);      # Until queue becomes empty    while (not q.empty()):          # Get the top element        temp = q.get()          # If the index is already        # visited. No need to        # traverse it again.        if (visited[temp] == True):            continue          # Mark temp as visited, if not        visited[temp] = True        if (temp == n - 1):              # If reached at the end            # of the array then break            reached = True            break          # If temp + arr[temp] and        # temp - arr[temp] are in        # the index of array        if (temp + arr[temp] < n):            q.put(temp + arr[temp])          if (temp - arr[temp] >= 0):            q.put(temp - arr[temp])      # If reaches the end of the array,    # Print "Yes"    if (reached == True):        print("Yes")      # Else print "No"    else:        print("No")  # Driver codeif __name__ == '__main__':      # Given array arr[]    arr = [ 4, 1, 3, 2, 5 ]      # starting index    S = 1    N = len(arr)      # Function call    solve(arr, N, S)  # This code is contributed by himanshu77
// C# program for the above approachusing System;using System.Collections.Generic; class GFG{ // Function to check if we can reach to// the end of the []arr with possible movesstatic void solve(int []arr, int n,                  int start){     // Queue to perform BFS    Queue<int> q = new Queue<int>();     // Initially all nodes(index)    // are not visited.    bool []visited = new bool[n];     // Initially the end of    // the array is not reached    bool reached = false;     // Push start index in queue    q.Enqueue(start);     // Until queue becomes empty    while (q.Count != 0)    {         // Get the top element        int temp = q.Peek();         // Delete popped element        q.Dequeue();         // If the index is already        // visited. No need to        // traverse it again.        if (visited[temp] == true)            continue;         // Mark temp as visited        // if not        visited[temp] = true;                 if (temp == n - 1)        {             // If reached at the end            // of the array then break            reached = true;            break;        }         // If temp + arr[temp] and        // temp - arr[temp] are in        // the index of array        if (temp + arr[temp] < n)        {            q.Enqueue(temp + arr[temp]);        }         if (temp - arr[temp] >= 0)        {            q.Enqueue(temp - arr[temp]);        }    }     // If reaches the end of the array,    // Print "Yes"    if (reached == true)    {        Console.Write("Yes");    }     // Else print "No"    else    {        Console.Write("No");    }} // Driver Codepublic static void Main(String[] args){         // Given array []arr    int []arr = { 4, 1, 3, 2, 5 };     // Starting index    int S = 1;    int N = arr.Length;     // Function call    solve(arr, N, S);}} // This code is contributed by gauravrajput1
<script> // Javascript program for the above approach // Function to check if we can reach to// the end of the arr[] with possible movesfunction solve(arr, n, start){         // Queue to perform BFS    let q = [];     // Initially all nodes(index)    // are not visited.    let visited = new Array(n);    visited.fill(false);     // Initially the end of    // the array is not reached    let reached = false;     // Push start index in queue    q.push(start);     // Until queue becomes empty    while (q.length > 0)    {                 // Get the top element        let temp = q[0];         // Delete popped element        q.shift();         // If the index is already        // visited. No need to        // traverse it again.        if (visited[temp] == true)            continue;         // Mark temp as visited        // if not        visited[temp] = true;        if (temp == n - 1)        {                         // If reached at the end            // of the array then break            reached = true;            break;        }         // If temp + arr[temp] and        // temp - arr[temp] are in        // the index of array        if (temp + arr[temp] < n)        {            q.push(temp + arr[temp]);        }         if (temp - arr[temp] >= 0)        {            q.push(temp - arr[temp]);        }    }     // If reaches the end of the array,    // Print "Yes"    if (reached == true)    {        document.write("Yes");    }     // Else print "No"    else    {        document.write("No");    }} // Driver code // Given array arr[]let arr = [ 4, 1, 3, 2, 5 ]; // Starting indexlet S = 1;let N = arr.length; // Function Callsolve(arr, N, S); // This code is contributed by divyeshrabadiya07  </script>
Yes
 
Time Complexity: O(N)  Auxiliary Space: O(N)
Approach 2: 
Another approach to the same can be by using recursion.Use recursion to jump to the i + arr[i] and i – arr[i] position of the array and check if we have reached the end or not.The advantage of using the recursion approach is that it simplifies the code a lot. Below is the implementation.
Another approach to the same can be by using recursion.
Use recursion to jump to the i + arr[i] and i – arr[i] position of the array and check if we have reached the end or not.
The advantage of using the recursion approach is that it simplifies the code a lot. Below is the implementation.
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <iostream>using namespace std;bool check_the_end(int arr[], int n, int i){       // If we have reached out of bounds    // of the array then return False    if (i < 0 or i >= n)        return false;     // If we have reached the end then return True    if (i == n - 1)        return true;     // Either of the condition return true solved the    // problem    return check_the_end(arr, n, i - arr[i])           or check_the_end(arr, n, i + arr[i]);} // Driver Codeint main(){    int arr[] = { 4, 1, 3, 2, 5 };    int S = 1;    int n = sizeof(arr) / sizeof(arr[0]);    bool result = check_the_end(arr, n, S);    cout << result; }     // This Code is Contributed by Harshit Srivastava
// Java program for the above approachimport java.io.*; class GFG {    static boolean check_the_end(int arr[], int n, int i)    {               // If we have reached out of bounds        // of the array then return False        if (i < 0 || i >= n)            return false;             // If we have reached the end then return True        if (i == n - 1)            return true;             // Either of the condition return true solved the        // problem        return check_the_end(arr, n, i - arr[i])               || check_the_end(arr, n, i + arr[i]);    }         // Driver Code    public static void main (String[] args) {        int arr[] = { 4, 1, 3, 2, 5 };        int S = 1;        int n = arr.length;        boolean result = check_the_end(arr, n, S);        System.out.println(result);         }} // This Code is Contributed by Shubhamsingh10
# Python program for the above approachdef check_the_end(arr, i):       # If we have reached out of bounds    # of the array then return False    if i < 0 or i >= len(arr):        return False           # If we have reached the end then return True    if i == len(arr) - 1:        return True           # Either of the condition return true solved the problem    return check_the_end(arr, i - arr[i]) or            check_the_end(arr, i + arr[i])  # Driver Codearr = [4, 1, 3, 2, 5]S = 1result = check_the_end(arr, S)print(result)
// C# program for the above approachusing System; public class GFG{    static bool check_the_end(int[] arr, int n, int i)    {               // If we have reached out of bounds        // of the array then return False        if (i < 0 || i >= n)            return false;             // If we have reached the end then return True        if (i == n - 1)            return true;             // Either of the condition return true solved the        // problem        return check_the_end(arr, n, i - arr[i])               || check_the_end(arr, n, i + arr[i]);    }         // Driver Code    static public void Main (){        int[] arr = { 4, 1, 3, 2, 5 };        int S = 1;        int n = arr.Length;        bool result = check_the_end(arr, n, S);        Console.WriteLine(result);         }} // This Code is Contributed by Shubhamsingh10
<script> // JavaScript program for the above approachfunction check_the_end(arr, n, i){    // If we have reached out of bounds    // of the array then return False    if (i < 0 || i >= n)        return false;      // If we have reached the end then return True    if (i == n - 1)        return true;      // Either of the condition return true solved the    // problem    return check_the_end(arr, n, i - arr[i])           || check_the_end(arr, n, i + arr[i]);} // Driver Codevar arr = [4, 1, 3, 2, 5];var S = 1var n = arr.length;var result = check_the_end(arr,n, S);document.write(result) // This code is contributed by Shivani </script>
Output:
True
Time Complexity: O(N)  Auxiliary Space: O(N)
himanshu77
GauravRajput1
divyanshujuneja01
srivastavaharshit848
shivanisinghss2110
divyeshrabadiya07
surindertarika1234
SHUBHAMSINGH10
pankajsharmagfg
clintra
Arrays
BFS
Algorithms
Arrays
Data Structures
Queue
Data Structures
Arrays
Queue
BFS
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
What is Hashing | A Complete Tutorial
Find if there is a path between two vertices in an undirected graph
How to Start Learning DSA?
Complete Roadmap To Learn DSA From Scratch
Types of Complexity Classes | P, NP, CoNP, NP hard and NP complete
Arrays in Java
Write a program to reverse an array or string
Maximum and minimum of an array using minimum number of comparisons
Largest Sum Contiguous Subarray
Arrays in C/C++