腾讯2020校园招聘后台开发面试编程题

腾讯一面的时候，面试官给出了一道题，题目如下，当初由于是第一次面试，比较紧张没做出来，现在回顾总结一下。

题目

小Q在周末的时候和他的小伙伴来到大城市逛街，一条步行街上有很多高楼，共有n座高楼排成一行。
小Q从第一栋一直走到了最后一栋，小Q从来都没有见到这么多的楼，所以他想知道他在每栋楼的位置处能看到多少栋楼呢？（当前面的楼的高度大于等于后面的楼时，后面的楼将被挡住）

输入描述

输入第一行将包含一个数字n，代表楼的栋数，接下来的一行将包含n个数字wi(1<=i<=n)，代表每一栋楼的高度。
1<=n<=100000;
1<=wi<=100000;

输出描述

输出一行，包含空格分割的n个数字vi，分别代表小Q在第i栋楼时能看到的楼的数量。

输入示例

6 5 3 8 3 2 5
输出示例
3 3 5 4 4 4

说明

当小Q处于位置3时，他可以向前看到位置2,1处的楼，向后看到位置4,6处的楼，加上第3栋楼，共可看到5栋楼。当小Q处于位置4时，他可以向前看到位置3处的楼，向后看到位置5,6处的楼，加上第4栋楼，共可看到4栋楼。

解法

暴力解

将输入数组逐个遍历，将当前元素和数组传给 getCanLooks()方法处理，getCanLooks() 方法将返回给元素能看到的楼层数。
在 getCanLooks() 方法中，分别往index的左边和index的右边遍历，遇到比 leftMax或者rightMax 大的，则将count++。
暴力解思路上是对的，本地IDE能跑，但是牛客上就超时了。

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int buildNum = scanner.nextInt();
		int[] array = new int[buildNum];
		for(int i=0;i<=buildNum-1;i++) {
			array[i] = scanner.nextInt();
		}
		
		//暴力解
		for(int i=0;i<=buildNum-1;i++) {
			System.out.print(getCanLooks(array,i) + " ");
		}
	}
	
	//获取该位置能看到的楼数
	public static int getCanLooks(int[] array, int index) {
		int thisHeight = array[index];
		int count = 1;	//本身为一栋，初始为1
		int left = index-1;
		int leftMax = Integer.MIN_VALUE;
		int right = index+1;
		int rightMax = Integer.MIN_VALUE;
		//从index位置往左遍历
		while(left >= 0) {
			if(array[left] > leftMax) {
				count++;
				leftMax = array[left];
			}
			left--;
		}
		//从index位置往右遍历
		while(right <= array.length-1) {
			if(array[right] > rightMax) {
				count++;
				rightMax = array[right];
			}
			right++;
		}
		return count;
	}
}

使用单调栈

这种方法的思路：
创建一个栈Stack用来记录从左往右看或者从右往左看能看到的楼层的下标;
创建leftLook数组用来记录从右往左看能看到的楼层数；
创建rightLook数组用来记录从左往右看能看到的楼层数；
分别从左往右和从右往左遍历一次，leftLook和rightLook分别记录，最后两者相加再+1就得到当前下标能看到的楼层数。

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

public class Main {
	public static void main(String[] args) {
	    Scanner sc = new Scanner(System.in);
	    int len = sc.nextInt();
	    int[] arr = new int[len];
	    for(int i = 0 ; i < len ; i++){
	        arr[i] = sc.nextInt();
	    }
	    //栈记录能看到的元素下标
	    Stack<Integer> stack = new Stack<>();
	    //记录往左看能看到的数量
	    int[] leftLook = new int[len];
	    //记录往右看能看到的数量
	    int[] rightLook = new int[len];
	    
	    //从右往左看
	    for(int i=0;i<=len-1;i++) {
	  	  //栈大小就是当前位置往左能看到的数量
	  	  leftLook[i] = stack.size();
	  	  //栈不为空，并且栈顶元素小于当前元素，将栈顶元素移除
	  	  while(!stack.isEmpty() && arr[i] >= arr[stack.peek()]) {
	  		  stack.pop();
	  	  }
	  	  //将当前元素下标入栈
	  	  stack.push(i);
	    }
	    //将栈清空
	    stack.clear();
	    
	    //从左往右看
	    for(int i=len-1;i>=0;i--) {
	  	  rightLook[i] = stack.size();
	  	  while(!stack.isEmpty() && arr[i] >= arr[stack.peek()]) {
	  		  stack.pop();
	  	  }
	  	  stack.push(i);
	    }
	    
	    //leftLook 和 rightLook相加，并加1
	    for(int i=0;i<=len-1;i++) {
	  	  leftLook[i] += 1+rightLook[i];
	  	  System.out.print(leftLook[i] + " ");
	    }
	}
}