There is a biker going on a road trip. The road trip consists of `n + 1`

points at different altitudes. The biker starts his trip on point `0`

with altitude equal `0`

.

You are given an integer array `gain`

of length `n`

where `gain[i]`

is the **net gain in altitude** between points `i`

and `i + 1`

for all (`0 <= i < n)`

. Return *the highest altitude of a point.*

**Example 1:**

Input:gain = [-5,1,5,0,-7]Output:1Explanation:The altitudes are [0,-5,-4,1,1,-6]. The highest is 1.

**Example 2:**

Input:gain = [-4,-3,-2,-1,4,3,2]Output:0Explanation:The altitudes are [0,-4,-7,-9,-10,-6,-3,-1]. The highest is 0.

**Constraints:**

`n == gain.length`

`1 <= n <= 100`

`-100 <= gain[i] <= 100`

` ````
```class Solution {
public:
int largestAltitude(vector& gain) {
// Initialize variables: maxx to store the maximum altitude, curr to keep track of the current altitude
int maxx = 0; // Initialize to 0 as the starting altitude
int curr = 0; // Initialize to 0 as the initial altitude
// Iterate through the gain vector
for (int i = 0; i < gain.size(); i++) {
// Update the current altitude by adding the current gain
curr += gain[i];
// Update maxx with the maximum of maxx and the current altitude
maxx = max(maxx, curr);
}
// Return the maximum altitude reached
return maxx;
}
};

Altitude refers to the height or elevation above a reference point, and in this program, we have to calculate the altitudes based on a series of gain values, where a gain represents a change in elevation. The altitude is starting from 0 and the task is to determine the maximum altitude that can be reached by accumulating these gains.

Let’s see the step-by-step approach to this solution.

- For this purpose, we have initialised two variables, ‘maxx’ and ‘curr’, both set to 0.

- ‘maxx’ is for storing the highest altitude encountered, while ‘curr’ is for keeping track of the current altitude.

- The ‘for’ loop is used to iterate through the array of gains. For each gain in the array, the current altitude (‘curr’) is updated by adding the current gain. Because every time it reaches the current height, addition or subtraction both things will take place; and addition or subtraction depends upon the sign convention so basically, if we just add the two of them, it will adjust, accordingly.

- Also, we will check at every point whether we have got our ‘maxx’ height or not. The ‘maxx’ variable is updated whenever the current altitude surpasses the highest altitude encountered so far.

- After traversing the entire array, the algorithm returns the final value of ‘maxx’, representing the highest altitude reached by accumulating gains.

**Summary:- **The solution effectively computes and tracks altitudes by iteratively adding gain values, ultimately determining the maximum altitude attainable from the given array.

Office:- 660, Sector 14A, Vasundhara, Ghaziabad, Uttar Pradesh - 201012, India