There are n buildings in a line. You are given an integer array heights of size n that represents the heights of the buildings in the line.

The ocean is to the right of the buildings. A building has an ocean view if the building can see the ocean without obstructions. Formally, a building has an ocean view if all the buildings to its right have a smaller height.

Return a list of indices (0-indexed) of buildings that have an ocean view, sorted in increasing order.

Input: heights = [4,2,3,1]
Output: [0,2,3]
Explanation: Building 1 (0-indexed) does not have an ocean view because building 2 is taller.

Input: heights = [4,3,2,1]
Output: [0,1,2,3]
Explanation: All the buildings have an ocean view.

Input: heights = [1,3,2,4]
Output: [3]
Explanation: Only building 3 has an ocean view.

1 <= heights.length <= 105
1 <= heights[i] <= 109

We know that the ocean is to the right side so we can add the last element index and then add all the elements greater than previous max element

class Solution {
    public int[] findBuildings(int[] heights) {
        List<Integer> result = new ArrayList<>();
        int latestMax = heights[heights.length-1];
        result.add(heights.length-1);
        for(int i=heights.length-2;i>=0;i--){
            if(heights[i]>latestMax){
                latestMax = heights[i];
                result.add(i);
            }
        }
        int[] res = new int[result.size()];
        int j=0;
        for(int i=result.size()-1;i>=0;i--){
            res[j] = result.get(i);
            j++;
        }
        return res;

    }
}

Time Complexity - O(N)

Space Complexity - O(N)