# Check if it is possible to reach to the index with value K when start index is given

• Last Updated : 18 Oct, 2021

Given an array arr[] of N positive integers and two positive integers S and K, the task is to reach the position of the array whose value is K 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 position of the array whose value is K then print “Yes” else print “No”.

Examples:

Input: arr[] = {4, 2, 3, 0, 3, 1, 2}, S = 5, K = 0.
Output: Yes
Explanation:
Initially we are standing at index 5 that is element 1 hence we can move one step forward or backward. Therefore, all possible ways to reach at index 3 with value 0 are:
index 5 -> index 4 -> index 1 -> index 3
index 5 -> index 6 -> index 4 -> index 1 -> index 3. Since it is possible to reach index 3 our output is yes.

Input: arr[] = {0, 3, 2, 1, 2}, S = 2, K = 3
Output: No
Explanation:
There is no way to reach index 1 with value 3.

Method 1 – Using BFS The Breadth-first search(BFS) approach is discussed below:

• Consider start index S as the source node and insert it into the queue.
• While the queue is not empty do the following:
1. Pop the element from the top of the queue say temp.
2. If temp is already visited or it is array out of bound index then, go to step 1.
3. Else mark it as visited.
4. Now if temp is the index of the array whose value is K, then print “Yes”.
5. Else take two possible destinations from temp to (temp + arr[temp]), (temp – arr[temp]) and push it into the queue.
• If the index with value K is not reached after the above steps then print “No”.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std;   // BFS approach to check if traversal // is possible or not bool check(int arr[], int& s_start,         int start, bool visited[],         int size, int K) {     queue q;       // Push start index into queue     q.push(start);       // Until queue is not empty     while (!q.empty()) {           // Top element of queue         int front = q.front();           // Pop the topmost element         q.pop();           // mark as visited         visited[front] = true;           if (arr[front] == K             && front != s_start) {             return true;         }           // Check for i + arr[i]         if (front + arr[front] >= 0             && front + arr[front] < size             && visited[front + arr[front]]                 == false) {               q.push(front + arr[front]);         }           // Check for i - arr[i]         if (front - arr[front] >= 0             && front - arr[front] < size             && visited[front - arr[front]]                 == false) {               q.push(front - arr[front]);         }     }       return false; }   // Function to check if index with value // K can be reached or not void solve(int arr[], int n, int start,         int K) {       // Initialize visited array     bool visited[n] = { false };       // BFS Traversal     bool ans = check(arr, start, start,                     visited, n, K);       // Print the result     if (ans)         cout << "Yes";     else         cout << "No"; }   // Driver Code int main() {     // Given array arr[]     int arr[] = { 3, 0, 2, 1, 2 };       // Given start and end     int start = 2;     int K = 0;       int N = sizeof(arr) / sizeof(arr[0]);       // Function Call     solve(arr, N, start, K);     return 0; }

## Java

 // Java program for the above approach import java.util.*; class GFG{     // BFS approach to check if traversal   // is possible or not   static boolean check(int arr[], int s_start, int start,                        boolean visited[], int size, int K)   {     Queue q = new LinkedList();       // Push start index into queue     q.add(start);       // Until queue is not empty     while (!q.isEmpty())     {         // Top element of queue       int front = q.peek();         // Pop the topmost element       q.remove();         // mark as visited       visited[front] = true;         if (arr[front] == K && front != s_start)       {         return true;       }         // Check for i + arr[i]       if (front + arr[front] >= 0 &&           front + arr[front] < size &&           visited[front + arr[front]] == false)       {           q.add(front + arr[front]);       }         // Check for i - arr[i]       if (front - arr[front] >= 0 &&           front - arr[front] < size &&           visited[front - arr[front]] == false)       {         q.add(front - arr[front]);       }     }       return false;   }     // Function to check if index with value   // K can be reached or not   static void solve(int arr[], int n, int start, int K)   {       // Initialize visited array     boolean visited[] = new boolean[n];       // BFS Traversal     boolean ans = check(arr, start, start,                         visited, n, K);       // Print the result     if (ans)       System.out.print("Yes");     else       System.out.print("No");   }     // Driver Code   public static void main(String[] args)   {     // Given array arr[]     int arr[] = { 3, 0, 2, 1, 2 };       // Given start and end     int start = 2;     int K = 0;       int N = arr.length;       // Function Call     solve(arr, N, start, K);   } }   // This code is contributed by Rohit_ranjan

## Python3

 # Python3 program for the above approach    # BFS approach to check if traversal # is possible or not def check(arr, s_start, start,           visited, size, K):       q = []        # Push start index into queue     q.append(start)        # Until queue is not empty     while (len(q) != 0):            # Top element of queue         front = q[-1]            # Pop the topmost element         q.pop(0)            # Mark as visited         visited[front] = True            if (arr[front] == K and front != s_start):             return True            # Check for i + arr[i]         if (front + arr[front] >= 0 and             front + arr[front] < size and             visited[front + arr[front]] == False):             q.append(front + arr[front])            # Check for i - arr[i]         if (front - arr[front] >= 0 and             front - arr[front] < size and             visited[front - arr[front]] == False):             q.append(front - arr[front])        return False       # Function to check if index with value # K can be reached or not def solve(arr, n, start, K):        # Initialize visited array     visited = [False for i in range(n)]        # BFS Traversal     ans = check(arr, start, start,                 visited, n, K)        # Print the result     if (ans):         print('Yes')     else:         print('No')   # Driver Code if __name__=="__main__":       # Given array arr[]     arr = [ 3, 0, 2, 1, 2 ]        # Given start and end     start = 2     K = 0        N = len(arr)        # Function Call     solve(arr, N, start, K)       # This code is contributed by rutvik_56

## C#

 // C# program for the above approach using System; using System.Collections.Generic;   class GFG{   // BFS approach to check if traversal // is possible or not static bool check(int []arr, int s_start, int start,                   bool []visited, int size, int K) {     Queue q = new Queue();       // Push start index into queue     q.Enqueue(start);       // Until queue is not empty     while (q.Count != 0)     {                   // Top element of queue         int front = q.Peek();               // Pop the topmost element         q.Dequeue();               // mark as visited         visited[front] = true;               if (arr[front] == K && front != s_start)         {             return true;         }               // Check for i + arr[i]         if (front + arr[front] >= 0 &&             front + arr[front] < size &&             visited[front + arr[front]] == false)         {             q.Enqueue(front + arr[front]);         }               // Check for i - arr[i]         if (front - arr[front] >= 0 &&             front - arr[front] < size &&             visited[front - arr[front]] == false)         {             q.Enqueue(front - arr[front]);         }     }     return false; }   // Function to check if index with value // K can be reached or not static void solve(int []arr, int n, int start,                   int K) {       // Initialize visited array     bool []visited = new bool[n];       // BFS Traversal     bool ans = check(arr, start, start,                      visited, n, K);       // Print the result     if (ans)         Console.Write("Yes");     else         Console.Write("No"); }   // Driver Code public static void Main(String[] args) {           // Given array []arr     int []arr = { 3, 0, 2, 1, 2 };       // Given start and end     int start = 2;     int K = 0;       int N = arr.Length;       // Function call     solve(arr, N, start, K); } }   // This code is contributed by Rohit_ranjan

## Javascript



Output

No

Time Complexity: O(N)
Auxiliary Space: O(N)

Method 2 – Using DFS: The Depth-first search(DFS) approach is discussed below:

1. Initialize an array visited[] to mark visited vertex as true.
2. Start with the start index S and explore other index depth-wise using recursion.
3. In each recursive call, we check if that index is valid or previously not visited. If not so, we return false.
4. Else if that index value is K, we return true.
5. Else mark that index as visited and process recursively for i + arr[i] and i – arr[i] from current index i.
6. If any of the recursive calls return true, this means that we reach to index with value K is possible and we print “Yes” Else print “No”.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std;   // DFS approach to check if traversal // is possible or not bool check(int arr[], int& s_start,         int start, bool visited[],         int size, int K) {     // Base cases     if (start < 0 || start >= size         || visited[start]) {         return false;     }       // Check if start index value K     if (arr[start] == K         && start != s_start) {         return true;     }       // Mark as visited     visited[start] = true;       // Check for both i + arr[i]     // and i - arr[i] recursively     return (check(arr, s_start,                 start + arr[start],                 visited, size, K)               || check(arr, s_start,                     start - arr[start],                     visited, size, K)); }   // Function to check if index with value // K can be reached or not void solve(int arr[], int n, int start,         int K) {       // Initialize visited array     bool visited[n] = { false };       // DFS Traversal     bool ans = check(arr, start, start,                     visited, n, K);       // Print the result     if (ans)         cout << "Yes";     else         cout << "No"; }   // Driver Code int main() {     // Given array arr[]     int arr[] = { 3, 0, 2, 1, 2 };       // Given start and end     int start = 2;     int K = 0;       int N = sizeof(arr) / sizeof(arr[0]);       // Function Call     solve(arr, N, start, K);     return 0; }

## Java

 // Java program for the above approach import java.util.Arrays;   class GFG{       // DFS approach to check if traversal // is possible or not public static boolean check(int[] arr, int s_start,                             int start, boolean[] visited,                             int size, int K) {           // Base cases     if (start < 0 || start >= size ||         visited[start])     {         return false;     }           // Check if start index value K     if (arr[start] == K &&             start != s_start)     {         return true;     }           // Mark as visited     visited[start] = true;           // Check for both i + arr[i]     // and i - arr[i] recursively     return (check(arr, s_start,                 start + arr[start],                 visited, size, K) ||             check(arr, s_start,                 start - arr[start],                 visited, size, K)); }       // Function to check if index with value // K can be reached or not public static void solve(int[] arr, int n,                         int start, int K) {           // Initialize visited array     boolean[] visited = new boolean[n];     Arrays.fill(visited, false);           // DFS Traversal     boolean ans = check(arr, start, start,                         visited, n, K);           // Print the result     if (ans)         System.out.print("Yes");     else         System.out.print("No"); }   // Driver code public static void main(String[] args) {           // Given array arr[]     int arr[] = { 3, 0, 2, 1, 2 };           // Given start and end     int start = 2;     int K = 0;           int N = arr.length;           // Function call     solve(arr, N, start, K); } }   // This code is contributed by divyeshrabadiya07

## Python3

 # Python3 program for the above approach   # DFS approach to check if traversal # is possible or not def check(arr, s_start, start, visited,           size, K):       # Base cases     if (start < 0 or start >= size or         visited[start]):         return False           # Check if start index value K     if (arr[start] == K and             start != s_start):         return True       # Mark as visited     visited[start] = True       # Check for both i + arr[i]     # and i - arr[i] recursively     return (check(arr, s_start,                   start + arr[start],                   visited, size, K) or             check(arr, s_start,                   start - arr[start],                   visited, size, K))   # Function to check if index with value # K can be reached or not def solve(arr, n, start, K):       # Initialize visited array     visited = [False] * n       # DFS Traversal     ans = check(arr, start, start,                 visited, n, K)       # Print the result     if (ans):         print("Yes")     else:         print("No")   # Driver Code if __name__ == "__main__":           # Given array arr[]     arr = [ 3, 0, 2, 1, 2 ]       # Given start and end     start = 2     K = 0       N = len(arr)       # Function call     solve(arr, N, start, K)   # This code is contributed by chitranayal

## C#

 // C# program for the above approach using System;   class GFG{       // DFS approach to check if traversal // is possible or not public static bool check(int[] arr, int s_start,                          int start, bool[] visited,                          int size, int K) {           // Base cases     if (start < 0 || start >= size||         visited[start])     {         return false;     }           // Check if start index value K     if (arr[start] == K &&             start != s_start)     {         return true;     }           // Mark as visited     visited[start] = true;           // Check for both i + arr[i]     // and i - arr[i] recursively     return (check(arr, s_start,                   start + arr[start],                   visited, size, K) ||             check(arr, s_start,                   start - arr[start],                   visited, size, K)); }       // Function to check if index with value // K can be reached or not public static void solve(int[] arr, int n,                          int start, int K) {           // Initialize visited array     bool[] visited = new bool[n];           // DFS Traversal     bool ans = check(arr, start, start,                      visited, n, K);           // Print the result     if (ans)         Console.Write("Yes");     else         Console.Write("No"); }   // Driver code public static void Main(String[] args) {           // Given array []arr     int []arr = { 3, 0, 2, 1, 2 };           // Given start and end     int start = 2;     int K = 0;           int N = arr.Length;           // Function call     solve(arr, N, start, K); } }   // This code is contributed by Princi Singh

## Javascript



Output

No

Time Complexity: O(N)
Auxiliary Space: O(N)

Method 3 : DFS (Efficient Method) : We will follow the steps mention below :

1. As array contains only positive number, so each time using dfs multiply that number with -1 which confirms that we have visited that element before.
2. Check if the given index element is same as K or not.
3. Otherwise, call dfs by increasing start + arr[start] and by decreasing start – arr[start].
4. In base case check if start is in range of array length and also check is it visited before or not.

Implementation of above approach :

## C++

 // C++ program for the above approach #include using namespace std;   // DFS approach to check if traversal // is possible or not bool dfs(int arr[], int N, int start, int K) {     // Base cases     if (start < 0 || start >= N || arr[start] < 0)         return false;       // Marking visited     arr[start] *= -1;       // Checking is that the element we needed or not     // otherwise making call for dfs again for different     // positions     return (abs(arr[start]) == K)            || dfs(arr, N, start + arr[start], K)            || dfs(arr, N, start - arr[start], K); }   // Driver Code int main() {     // Given array arr[]     int arr[] = { 3, 0, 2, 1, 2 };       // Given start and end     int start = 2;     int K = 0;       int N = sizeof(arr) / sizeof(arr[0]);       // Function Call     bool flag = dfs(arr, N, start, K);     if (flag)         cout << "Yes";     else         cout << "No";     return 0; }

## Java

 // Java program for the above approach import java.util.Arrays;   class GFG {       // DFS approach to check if traversal     // is possible or not     public static boolean dfs(int[] arr, int N, int start,                               int K)     {         // Base Cases         if (start < 0 || start >= N || arr[start] < 0)             return false;           // Marking visited         arr[start] *= -1;           // Checking is that the element we needed or not         // otherwise making call for dfs again for different         // positions         return (Math.abs(arr[start]) == K)             || dfs(arr, N, start + arr[start], K)             || dfs(arr, N, start - arr[start], K);     }       // Driver code     public static void main(String[] args)     {           // Given array arr[]         int arr[] = { 3, 0, 2, 1, 2 };           // Given start and end         int start = 2;         int K = 0;           int N = arr.length;           // Function call         if (dfs(arr, N, start, K))             System.out.println("Yes");         else             System.out.println("No");     } }

## Python3

 # Python3 program for the above approach   # DFS approach to check if traversal # is possible or not def dfs(arr, N, start, K):     # Base Cases     if start < 0 or start >= N or arr[start] < 0:         return False       # Marking visited     arr[start] *= -1       # Checking is that the element we needed or not     # otherwise making call for dfs again for different positions     return abs(arr[start]) == K or dfs(arr, N, start + arr[start], K) or dfs(arr, N, start - arr[start], K)       # Given array arr[] arr = [ 3, 0, 2, 1, 2 ]   # Given start and end start = 2 K = 0   N = len(arr)   # Function call if dfs(arr, N, start, K):   print("Yes") else:   print("No")       # This code is contributed by divyesh072019.

## C#

 // C# program for the above approach using System; using System.Collections.Generic; class GFG {           // DFS approach to check if traversal     // is possible or not     static bool dfs(int[] arr, int N, int start, int K)     {                 // Base Cases         if (start < 0 || start >= N || arr[start] < 0)             return false;            // Marking visited         arr[start] *= -1;            // Checking is that the element we needed or not         // otherwise making call for dfs again for different         // positions         return (Math.Abs(arr[start]) == K)             || dfs(arr, N, start + arr[start], K)             || dfs(arr, N, start - arr[start], K);     }         static void Main()   {           // Given array arr[]     int[] arr = { 3, 0, 2, 1, 2 };       // Given start and end     int start = 2;     int K = 0;       int N = arr.Length;       // Function call     if (dfs(arr, N, start, K))         Console.Write("Yes");     else         Console.Write("No");   } }   // This code is contributed by rameshtravel07.

## Javascript



Output

No

Time Complexity : O(n)

Auxiliary Space : O(n), (Space is only used for recursion)

My Personal Notes arrow_drop_up
Recommended Articles
Page :