Most efficient way to calculate count of consecutive buildings that are shorter than current buildings

In below code snippet The program calculates the count of consecutive buildings that are shorter than the current building. It starts with an initial count of 0 and adds 1 to the count for each building that is shorter than the current building. When it encounters a building that is taller or equal, it adds the current count to the total count and resets the count to 0.
but this solution's time complexity is o (n2) and doesn't look more effective if no. of building is more . How to improve this solution ? Any suggested pointer will be helpful for me.

Note: Array of building size >=6 and <=80000 and height of building can be 1 to 100000000

#include <iostream>
using namespace std;

int main()
{
    cout<<"Hello World";
    
    int N;

int count = 0;
int total_count = 0;

int output ;

int H [] = {5,3,4,2,6,1};

int size = sizeof(H) / sizeof(H[0]);


for (int i = 0; i < size ; i++)
	{
	 for (int j = i+1 ; j < size ; j++)	
	 {
		 
		 if (H[i] > H[j])
		 {
			 
			 count ++;
			 
			 std::cout<<"count value  = " << count << H[i] << std::endl;
			 
			}
		 
		 else
		 {
		
			 
			 total_count = total_count + count ;
			 
			 count = 0;
			 break;
		 }
		 
		 
	 }
		
		
	} 
	//	Write the code
     total_count = total_count + count ;
	
		 
     output = total_count;
	 cout << "output = "<<output << endl;	//	Output right answer
	return 0;
}

This is an O(n) method

The main idea is that we are not interested to count the numbers of lower elements of each sample, but the total sum of them.

This allows another approach. For each new element, we count the number of elements which are higher than the current one, which are memorized in a stack.

Therefore, for each new element, we suppress the elements which are lower or equal, and then add the size of the stack to the total count.
The new element is then added to the stack.

Ths complexity is O(n) because each element is added or removed only once to/from the stack.

The following code compares the result of the new approach with the brute-force O(n^2) one.

#include <iostream>
#include <vector>
#include <stack>

//  Brute-force (OP) method

int count_bf (const std::vector<int>& H) {
    int size = H.size();
    int total_count = 0;
    for (int i = 0; i < size ; i++) {
        for (int j = i+1 ; j < size ; j++) {
            if (H[i] > H[j]){
                total_count ++;
            } else {
                break;
            }
        }
    } 
    return total_count;
}

// Fast method

int count_fast (const std::vector<int>& H) {
    int size = H.size();
    int total_count = 0;
    std::stack<int> lifo;
    for (int i = 0; i < size ; i++) {
        while (!lifo.empty() && (lifo.top() <= H[i])) {
            lifo.pop();
        }
        total_count += lifo.size();
        lifo.push(H[i]);
    } 
    return total_count;
}

int main() {    
    std::vector<int> H = {5, 3, 4, 2, 6, 1, 13, 15, 17, 14, 13};

    int total_count = count_bf(H);
    std::cout << "output brute-force method = "<< total_count << std::endl;
    total_count = count_fast(H);
    std::cout << "output fast method = "<< total_count << std::endl;
    return 0;
}