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

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to check if we can reach to
// the end of the []arr with possible moves
static 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 Code
public 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

using System;

public class GFG
{
    public static bool CanReachEnd(int[] arr, int pos)
    {
        // Base case: If the current position is the last 
        // index of the array then we can reach the end.
        if (pos == arr.Length - 1)
        {
            return true;
        }

        // Recursive case: Try all possible jumps from the current position.
        int maxJump = Math.Min(pos + arr[pos], arr.Length - 1);
        for (int nextPos = pos + 1; nextPos <= maxJump; nextPos++)
        {
            if (CanReachEnd(arr, nextPos))
            {
                return true;
            }
        }

        // If we can't reach the end from any of the possible jumps, return false.
        return false;
    }

    public static void Main(string[] args)
    {
        int[] arr = { 4, 1, 3, 2, 5 };
        int startPos = 1;

        // Example usage
        if (CanReachEnd(arr, startPos))
        {
            Console.WriteLine("Yes");
        }
        else
        {
            Console.WriteLine("No");
        }
    }
}