Buildings With an Ocean View

class Solution {
public:
    vector<int> findOceanViewBuildings(vector<int>& heights) {
        int totalBuildings = heights.size();
        vector<int> result;
        int tallestSoFar = -1;
        
        for (int index = totalBuildings - 1; index >= 0; --index) {
            if (tallestSoFar < heights[index]) {
                result.push_back(index);
                tallestSoFar = heights[index];
            }
        }
        
        reverse(result.begin(), result.end());
        return result;
    }
};

The solution is designed to determine which buildings in a list have an unobstructed view of the ocean. The buildings are represented as a vector of integers where each integer denotes the height of a building. The buildings are evaluated from the perspective that the ocean is to the right of the last building in the array.

The approach used in this C++ solution is both efficient and straightforward, utilizing a single pass scan from right to left. This direction is chosen because a building will only have an ocean view if there are no taller buildings to its right. Here’s a breakdown of the solution:

1. Initialize an empty vector result to store the indices of buildings with an ocean view.
2. Start with tallestSoFar set to -1, which will track the height of the tallest building encountered so far from the right.
3. Iterate through the buildings from right to left. For each building, compare its height with tallestSoFar:
   • If the current building is taller than tallestSoFar, it has an ocean view. Add the building's index to result and update tallestSoFar to the current building’s height.
4. After the loop completes, reverse the result vector to present building indices in left-to-right order.
5. Return the result vector.

The function returns a vector of indices of buildings that have an ocean view in an increasing order, enabling efficient identification of structures that meet the criteria.

class Solution {
    public int[] oceanViewBuildings(int[] buildings) {
        int total = buildings.length;
        ArrayList<Integer> visibleBuildings = new ArrayList<>();
        int highestYet = Integer.MIN_VALUE;
        
        for (int i = total - 1; i >= 0; i--) {
            if (buildings[i] > highestYet) {
                visibleBuildings.add(i);
                highestYet = buildings[i];
            }
        }
        
        int[] result = new int[visibleBuildings.size()];
        for (int j = 0; j < visibleBuildings.size(); j++) {
            result[j] = visibleBuildings.get(visibleBuildings.size() - 1 - j);
        }
        
        return result;
    }
}

The given Java solution aims to determine which buildings have an ocean view, given that they are all lined up from left to right and the ocean is to their right. The method oceanViewBuildings takes an array buildings where each element represents the height of a building.

Here's a succinct breakdown of the approach:

• Start by assessing the buildings from right to left since the ocean is on the right side. This allows for immediate comparison with the last seen (or easternmost) building.
• Utilize an integer highestYet initialized to Integer.MIN_VALUE to keep track of the highest building encountered as you iterate from the right. This tracking helps in determining which buildings have an unrestricted view of the ocean.
• Use an ArrayList<Integer> visibleBuildings to store the indices of the buildings with an ocean view. A building has an ocean view if its height is greater than highestYet at that point.
• Update highestYet whenever a taller building is found.
• For the output, the indices in visibleBuildings need to be reversed because they were collected from right to left. Create an array result and populate it by iterating over visibleBuildings in reverse order.

Thus, the final output returns the indices of all buildings with an ocean view in left to right order, effectively solving the problem by leveraging a simple but efficient method of iterating in reverse and keeping track of the highest building seen so far.

let oceanViewBuildings = function(buildingHeights) {
    let totalBuildings = buildingHeights.length;
    let viewableBuildings = [];
    let tallestSeen = -1;

    for (let idx = totalBuildings - 1; idx >= 0; idx--) {
        if (tallestSeen < buildingHeights[idx]) {
            viewableBuildings.push(idx);
            tallestSeen = buildingHeights[idx];
        }
    }
    viewableBuildings.reverse();
    return viewableBuildings;
};

In the JavaScript solution provided, the goal is to identify buildings that have an unobstructed view of the ocean. The function oceanViewBuildings takes an array of integers, buildingHeights, each representing the height of a building from left to right as they face the ocean.

To find out which buildings have a clear view of the ocean:

1. Initialize totalBuildings to the size of the buildingHeights array.
2. Create an empty array viewableBuildings to store indices of buildings with ocean views.
3. Use a variable tallestSeen initialized to -1 to keep track of the tallest building height encountered as you iterate from right to left.

Iterate over buildingHeights from the last building to the first:

1. Compare tallestSeen with the current building's height.
2. If the current building is taller than tallestSeen, add its index to viewableBuildings and update tallestSeen to this building's height.
3. After finishing the loop, reverse the viewableBuildings array to ensure it represents buildings from left to right.

Return viewableBuildings, which now contains indices of all buildings that have an unobstructed view of the ocean. This solution efficiently traverses the list once in reverse to minimize computations and efficiently resolve the challenge.

class Solution:
    def getViewableBuildings(self, buildings: List[int]) -> List[int]:
        total = len(buildings)
        result = []
        tallest = -1

        for index in reversed(range(total)):
            if tallest < buildings[index]:
                result.append(index)
                tallest = buildings[index]

        result.reverse()
        return result

The solution for the "Buildings With an Ocean View" problem is written in Python3. It involves iterating over an array of building heights to determine which buildings have an unblocked view of the ocean. The strategy uses the following approach:

• Initialize an empty list result to store the indices of buildings with an ocean view.
• Start with a variable tallest set to -1, which will keep track of the tallest building encountered so far from the rightmost side of the list.
• Iterate over the list of buildings in reverse order using a loop. For each building:
  • Compare the current building's height to the tallest. If the current building is taller, add its index to the result list and update tallest to this building's height.
• After the loop, reverse the result list to present indices in left-to-right order.
• Return the result, which contains indices of buildings with an ocean view.

This algorithm ensures that each building is checked against the maximum height found to its right, aligning with the idea that a building can see the ocean if it is taller than any building to its right. The use of reversal and tracking the highest structures optimizes the solution, making it efficient and straightforward to understand.