逛街

if __name__=='__main__':
    n=int(input())
    a = list(map(int, input().split()))
    #left right为栈
    left=[]
    right=[]
    l_num=[]
    r_num=[]
    for i in range(len(a)):#向左看
        l_num.append(len(left))
        if(i==0):#第一个值特殊处理
            left.append(a[i])
        elif(a[i]<left[-1]):# 入栈操作
            left.append(a[i])
        else:
            while(len(left)!=0 and a[i]>=left[-1]):
                left.pop(-1)
            left.append(a[i])
    a.reverse()
    for i in range(len(a)):#向右看
        r_num.append(len(right))
        if(i==0):#第一个值特殊处理
            right.append(a[i])
        elif(a[i]<right[-1]):# 入栈操作
            right.append(a[i])
        else:
            while(len(right)!=0 and a[i]>=right[-1]):
                right.pop(-1)
            right.append(a[i])
    r_num.reverse()
    #print(l_num)
    #print(r_num)
    ans=[]
    for i in range(len(a)):
       ans.append(l_num[i]+r_num[i]+1)
    ansstr=' '.join([str(i) for i in ans])
    print(ansstr)

// 递减栈 栈中元素数目即为能看到的楼数目
// 两个栈 一个表示向左能看到的数目 一个表示向右 注意所有栈都不考虑当前所在楼本身 因此最后结果要加1
// 以向右看为例
// 单调栈里维护了从最左边到该位置前递减序列 而到达当前位置的递减序列对于当前位置来 都是可见的
// 因此单调栈的大小保存了能看到楼的个数

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Stack;

public class Tencent2020backend2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] height = new int[n];
        for(int i=0; i<n; i++) {
            height[i] = sc.nextInt();
        }

        Stack<Integer> stack1 = new Stack<>();
        Stack<Integer> stack2 = new Stack<>();
        ArrayList<Integer> count1 = new ArrayList<>();
        ArrayList<Integer> count2 = new ArrayList<>();

        for(int i = 0, j = height.length-1; i < height.length && j>=0; i++, j--) {
            count1.add(stack1.size());
            count2.add(0, stack2.size());
            while(!stack1.empty() && stack1.peek() <= height[i]) stack1.pop();
            while(!stack2.empty() && stack2.peek() <= height[j]) stack2.pop();
            stack1.push(height[i]);
            stack2.push(height[j]);
        }
        for(int i=0; i<n; i++) {
            System.out.print(count1.get(i) + count2.get(i) + 1 + " ");
        }
    }
}

// 递增栈

// for(int i=0; i<arr.size; i++) {
//     while(!stack.empty() && stack.peek() > arr[i]) stack.pop();
// }

// 单增栈能以O(n)复杂度找到每一个元素的前下界
// 同理单减栈能以O(n)复杂度找到每一个元素的前上界
// 本题中到达前上界包含的位置数目即为能看到楼宇数
// 前上界之后的楼不可见

let N = readline();
let Bu = readline();
let B = Bu.split(' ').map(Number);
//B = B.map(Number);

function buildingSaw(arrOri) {
        let len = arrOri.length;
        let arr = arrOri;
        let right= new Array(len);
        let stack = new Stack();
        let resBuild = [];

        for (let i = len - 1; i >= 0; i--) {
            right[i] = stack.length();
            while (stack.length() && arr[i] >= arr[stack.peek()]) {
                stack.pop();
            }
            stack.push(i);
        }
        stack.clear();
        for (let j = 0; j < len; j++) {
            let total = right[j] + 1 + stack.length();
            while (stack.length() && arr[j] >= arr[stack.peek()]) {
                stack.pop();
            }            
            resBuild.push(total);
            stack.push(j);
        }
        return resBuild;
        
    }

    function Stack() {
        this.dataStore = []; //Init
        this.top = 0; //栈顶位置
        this.pop = pop; //出栈
        this.push = push; //入栈
        this.peek = peek; //栈顶元素
        this.length = length; //栈内元素总数
        this.clear = clear; //清空栈
    }

    function push(e) {
        this.dataStore[this.top++] = e;
    }

    function pop() {
        return this.dataStore[--this.top];
    }

    function peek() {
        if (this.top > 0) return this.dataStore[this.top - 1];
        else return 'Empty';
    }

    function length() {
        return this.top;
    }

    function clear() {
        delete this.dataStore;
        this.dataStore = [];
        this.top = 0;
    }

let result = buildingSaw(B).join(' ');
console.log(result)

def buildings(n, nums):
    lstack, rstack = [nums[0]], [nums[n-1]]
    lrst, rrst =[1], [1]
    for i in range(1,n):
        lrst.append(len(lstack)+1)
        rrst.append(len(rstack)+1)
        while len(lstack)!=0 and nums[i]>=lstack[-1]:lstack.pop()
        while len(rstack)!=0 and nums[n-1-i]>=rstack[-1]:rstack.pop()
        lstack.append(nums[i])
        rstack.append(nums[n-1-i])
    rrst = [r for r in reversed(rrst)]
    res =[lrst[i] + rrst[i] -1 for i in range(n)]
    return res
 
if __name__ == "__main__":
    n = int(input())
    nums = list(map(int, input().split(' ')))
    res = buildings(n, nums)
    print(" ".join(list(map(str, res))))

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Stack;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine().trim());
        String[] strH = br.readLine().trim().split(" ");
        int[] h = new int[n];
        for(int i = 0; i < n; i++) h[i] = Integer.parseInt(strH[i]);
        Stack<Integer> stack = new Stack<>();
        // right[i]用来存储第i个位置向右看能看到的楼的数目
        int[] right = new int[n];
        for(int i = n - 1; i >= 0; i--){
            right[i] = stack.size();
            /* 保证栈是单调递增的，如果在向左遍历的过程中发现了比栈顶更高的楼i，
            说明对于再往左一个位置的i-1而言，楼i后面更矮的楼是看不到的（高的能看到），
            因此将比楼i高度小的楼全部弹出*/
            while(!stack.isEmpty() && h[i] >= h[stack.peek()]) stack.pop();
            // 比栈顶小，则往栈中添加
            stack.push(i);
        }
        stack.clear();
        // 往右看完了再往左看
        for(int i = 0; i < n; i++){
            // 右边+自己+左边
            int totalI = right[i] + 1 + stack.size();
            while(!stack.isEmpty() && h[i] >= h[stack.peek()]) stack.pop();
            System.out.print(totalI + " ");
            stack.push(i);
        }
    }
}

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

using namespace std;

// 6
// 5 3 8 3 2 5
int main()
{
	int n = 0;
	while(cin >> n){
		vector<int> hight(n);

		for(auto &i : hight)
		{
			cin >> i;
		}

		vector<int> ltor(n);
		vector<int> rtol(n);

		stack<int> s1;

		//从左往右记录遍历所有位置，ltor[i]是记录站在i栋楼处，能看到左边的多少栋楼
		for (int i = 0; i < n; i++) {

			ltor[i] = s1.size(); //栈的size即为所能看到楼的数量

			//如果栈不为空，且顶小于vi，则出栈, s1.top代表上一栋楼的高度,
			//如果当前楼高度高于上一栋楼，则表明当前位置（包括后面的楼）都看不到该楼，所以可以出栈, 且可以继续检查栈顶，
			//直到找到能符合条件的栈顶，此时size即为当前楼所能看到的左侧楼数量
			while (!s1.empty() && s1.top() <= hight[i]) {
				s1.pop();
			}

			// l0 = s1.size() = 0;
			// 将vi入栈, 第一次压入5，
			// i++, i = 1，l1 = 1, top = 5, 所以top>3, 不会弹出，压入v1 = 3，
			// i = 2, l2 = s1.size = 2, 
			// ltor结果: 0 1 2 1 2 3
			s1.push(hight[i]);
		}

		//测试
		// for(auto i : ltor)
		// {
			// cout << i << " ";
		// }

		stack<int>s2;
		//从右往左遍历，记录当前位置能看到的右侧的楼的数量
		for (int i = n - 1; i >= 0; i--) {
			rtol[i] = s2.size();
			while (!s2.empty() && hight[i] >= s2.top()) {
				s2.pop();
			}
			s2.push(hight[i]);
		}

		for (int i = 0; i < n; i++) {
			cout << ltor[i] + rtol[i] + 1 << " ";
		}

		cout << endl;
	}

	return 0;
}

let N = parseInt(readline());
let Bu = readline().split(' ').map(Number);

const res = []
let stack = []

for(let i = 0; i < N; i ++){
    res[i] = stack.length;
    while(stack[stack.length-1] <= Bu[i]) stack.pop();
    stack.push(Bu[i]);
}
stack = []
for(let i = N-1; i >= 0; i --){
    res[i] = res[i]+stack.length+1;
    while(stack[stack.length-1] <= Bu[i]) stack.pop();
    stack.push(Bu[i]);
}
console.log(res.join(' '))