Given an array **arr[]** consisting of **N **integers and three integers **X**, **Y**, and **K**, the task is to find the farthest index that can be reached by the following operations:

**If arr[i] ≥ arr[i + 1]:**Move from index**i**to**i + 1**.**If arr[i] < arr[i+1]:**Either decrement**X**by**1**if the value of**X > 0**or decrement**Y**by**(arr[i + 1] – arr[i])**if the value of**Y**>**(arr[i+1] – arr[i])**.

**Examples:**

Input:arr[] = {4, 2, 7, 6, 9, 14, 12}, X = 1, Y = 5, K = 0Output:4Explanation:

Initially, K = 0.

arr[0] > arr[1]: Therefore, move to index 1.

arr[1] < arr[2]: Decrement X by 1 and move to index 2. Now X = 0.

arr[2] > arr[3]: Move to index 3.

arr[3] < arr[4]: Decrement Y by 3 and move to index 4. Now Y = 2

arr[4] < arr[5]: Neither X > 0 nor Y > 5. Hence, it is not possible to move to the next index.

Therefore, the maximum index that can be reached is 4.

Input:arr[] = {14, 3, 19, 3}, X = 17, Y = 0, K = 1Output:3

**Approach:** The idea is to use **X **for the maximum difference between indexes and **Y **for the remaining difference. Follow the steps below to solve this problem:

- Declare a priority queue.
- Traverse the given array
**arr[]**and perform the following operations:- If the current element (
**arr[i]**) is greater than the next element (**arr[i + 1]**), then move to the next index. - Otherwise, push the difference of
**(arr[i + 1] – arr[i])**into the**priority queue**. - If the size of the priority queue is greater than
**Y**, then decrement**X**by the top element of the**priority queue**and**pop**that element. - If
**X**is less than**0**, the farthest index that can be reached is**i**.

- If the current element (
- After completing the above steps, if the value of
**X**is**at least 0**, then the farthest index that can be reached is**(N – 1)**.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the farthest index` `// that can be reached` `void` `farthestHill(` `int` `arr[], ` `int` `X,` ` ` `int` `Y, ` `int` `N, ` `int` `K)` `{` ` ` `int` `i, diff;` ` ` `// Declare a priority queue` ` ` `priority_queue<` `int` `> pq;` ` ` `// Iterate the array` ` ` `for` `(i = K; i < N - 1; i++) {` ` ` `// If current element is` ` ` `// greater than the next element` ` ` `if` `(arr[i] >= arr[i + 1])` ` ` `continue` `;` ` ` `// Otherwise, store their difference` ` ` `diff = arr[i + 1] - arr[i];` ` ` `// Push diff into pq` ` ` `pq.push(diff);` ` ` `// If size of pq exceeds Y` ` ` `if` `(pq.size() > Y) {` ` ` `// Decrease X by the` ` ` `// top element of pq` ` ` `X -= pq.top();` ` ` `// Remove top of pq` ` ` `pq.pop();` ` ` `}` ` ` `// If X is exhausted` ` ` `if` `(X < 0) {` ` ` `// Current index is the` ` ` `// farthest possible` ` ` `cout << i;` ` ` `return` `;` ` ` `}` ` ` `}` ` ` `// Print N-1 as farthest index` ` ` `cout << N - 1;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 4, 2, 7, 6, 9, 14, 12 };` ` ` `int` `X = 5, Y = 1;` ` ` `int` `K = 0;` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `// Function Call` ` ` `farthestHill(arr, X, Y, N, K);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` ` ` `// Function to find the farthest index ` `// that can be reached ` `public` `static` `void` `farthestHill(` `int` `arr[], ` `int` `X, ` ` ` `int` `Y, ` `int` `N, ` `int` `K) ` `{ ` ` ` `int` `i, diff; ` ` ` ` ` `// Declare a priority queue ` ` ` `PriorityQueue<Integer> pq = ` `new` `PriorityQueue<Integer>();` ` ` ` ` `// Iterate the array ` ` ` `for` `(i = K; i < N - ` `1` `; i++)` ` ` `{ ` ` ` ` ` `// If current element is ` ` ` `// greater than the next element ` ` ` `if` `(arr[i] >= arr[i + ` `1` `]) ` ` ` `continue` `; ` ` ` ` ` `// Otherwise, store their difference ` ` ` `diff = arr[i + ` `1` `] - arr[i]; ` ` ` ` ` `// Push diff into pq ` ` ` `pq.add(diff); ` ` ` ` ` `// If size of pq exceeds Y ` ` ` `if` `(pq.size() > Y)` ` ` `{ ` ` ` ` ` `// Decrease X by the ` ` ` `// top element of pq ` ` ` `X -= pq.peek(); ` ` ` ` ` `// Remove top of pq ` ` ` `pq.poll(); ` ` ` `} ` ` ` ` ` `// If X is exhausted ` ` ` `if` `(X < ` `0` `)` ` ` `{ ` ` ` ` ` `// Current index is the ` ` ` `// farthest possible ` ` ` `System.out.print(i); ` ` ` `return` `; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Print N-1 as farthest index ` ` ` `System.out.print(N - ` `1` `); ` `} ` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `4` `, ` `2` `, ` `7` `, ` `6` `, ` `9` `, ` `14` `, ` `12` `}; ` ` ` `int` `X = ` `5` `, Y = ` `1` `; ` ` ` `int` `K = ` `0` `; ` ` ` `int` `N = arr.length; ` ` ` ` ` `// Function Call ` ` ` `farthestHill(arr, X, Y, N, K); ` `}` `}` `// This code is contributed by divyeshrabadiya07` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program for the above approach` ` ` `# Function to find the farthest index` `# that can be reached` `def` `farthestHill(arr, X, Y, N, K):` ` ` ` ` `# Declare a priority queue` ` ` `pq ` `=` `[]` ` ` ` ` `# Iterate the array` ` ` `for` `i ` `in` `range` `(K, N ` `-` `1` `, ` `1` `):` ` ` ` ` `# If current element is` ` ` `# greater than the next element` ` ` `if` `(arr[i] >` `=` `arr[i ` `+` `1` `]):` ` ` `continue` ` ` ` ` `# Otherwise, store their difference` ` ` `diff ` `=` `arr[i ` `+` `1` `] ` `-` `arr[i]` ` ` ` ` `# Push diff into pq` ` ` `pq.append(diff)` ` ` ` ` `# If size of pq exceeds Y` ` ` `if` `(` `len` `(pq) > Y):` ` ` ` ` `# Decrease X by the` ` ` `# top element of pq` ` ` `X ` `-` `=` `pq[` `-` `1` `]` ` ` ` ` `# Remove top of pq` ` ` `pq[` `-` `1` `]` ` ` ` ` `# If X is exhausted` ` ` `if` `(X < ` `0` `):` ` ` ` ` `# Current index is the` ` ` `# farthest possible` ` ` `print` `(i)` ` ` `return` ` ` ` ` `# Print N-1 as farthest index` ` ` `print` `(N ` `-` `1` `)` `# Driver Code` `arr ` `=` `[ ` `4` `, ` `2` `, ` `7` `, ` `6` `, ` `9` `, ` `14` `, ` `12` `]` `X ` `=` `5` `Y ` `=` `1` `K ` `=` `0` `N ` `=` `len` `(arr)` ` ` `# Function Call` `farthestHill(arr, X, Y, N, K)` `# This code is contributed by code_hunt` |

*chevron_right*

*filter_none*

## C#

`// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the farthest index` `// that can be reached` `public` `static` `void` `farthestHill(` `int` `[] arr, ` `int` `X,` ` ` `int` `Y, ` `int` `N, ` `int` `K)` `{` ` ` `int` `i, diff;` ` ` ` ` `// Declare a priority queue` ` ` `List<` `int` `> pq = ` `new` `List<` `int` `>();` ` ` ` ` `// Iterate the array` ` ` `for` `(i = K; i < N - 1; i++)` ` ` `{` ` ` ` ` `// If current element is` ` ` `// greater than the next element` ` ` `if` `(arr[i] >= arr[i + 1])` ` ` `continue` `;` ` ` ` ` `// Otherwise, store their difference` ` ` `diff = arr[i + 1] - arr[i];` ` ` ` ` `// Push diff into pq` ` ` `pq.Add(diff);` ` ` `pq.Sort();` ` ` `pq.Reverse();` ` ` ` ` `// If size of pq exceeds Y` ` ` `if` `(pq.Count > Y)` ` ` `{` ` ` ` ` `// Decrease X by the` ` ` `// top element of pq` ` ` `X -= pq[0];` ` ` ` ` `// Remove top of pq` ` ` `pq.RemoveAt(0);` ` ` `}` ` ` `// If X is exhausted` ` ` `if` `(X < 0) ` ` ` `{` ` ` ` ` `// Current index is the` ` ` `// farthest possible` ` ` `Console.Write(i);` ` ` `return` `;` ` ` `}` ` ` `}` ` ` ` ` `// Print N-1 as farthest index` ` ` `Console.Write(N - 1);` `}` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[] arr = { 4, 2, 7, 6, 9, 14, 12 };` ` ` `int` `X = 5, Y = 1;` ` ` `int` `K = 0;` ` ` `int` `N = arr.Length;` ` ` ` ` `// Function Call` ` ` `farthestHill(arr, X, Y, N, K);` `}` `}` `// This code is contributed by gauravrajput1` |

*chevron_right*

*filter_none*

**Output:**

4

**Time Complexity:** O(N*log(E)), where E is the maximum number of elements in the priority queue.**Auxiliary Space:** O(E)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.