腾讯笔试题:逛街

题目

时间限制：C/C++ 2秒，其他语言4秒

空间限制：C/C++ 256M，其他语言512M

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

输入例子1:
[5,3,8,3,2,5]

输出例子1:
[3,3,5,4,4,4]

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

输入为一个数组，表示每一栋楼的高度w[i]
1<=数组长度<=100000;
1<=wi<=100000; 

解答

package offer.tengxun;

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

public class Shopping 
{
	public static void main(String[] args)
	{
		Scanner in = new Scanner(System.in);
		String line = in.nextLine();
		line = line.replace("[", "");
		line = line.replace("]", "");
		in.close();
		String[] arr = line.split(",");
		int[] data = new int[arr.length];
		for (int x = 0; x < arr.length; x++)
		{
			data[x] = Integer.parseInt(arr[x]);
		}
		int[] reslut = findBuilding3(data);
		System.out.print("[");
		for (int x=0;x<reslut.length;x++)
		{
			if(x==reslut.length-1)
			{
				System.out.print(reslut[x]);
			}
			else
			{
				System.out.print(reslut[x]+",");
			}
		}
		System.out.print("]");
	}
	/*
	 * 这属于暴力解决了,遍历了两次这个数据,时间复杂度是n^2
	 * 题目数据量是10^5,运算量到达10^10,超时了
	 */
	public static int[] findBuilding1(int[] heights)
	{
		int[] data=new int[heights.length];
		Arrays.fill(data, 1);
		for(int x= 0;x<data.length;x++)
		{
			int index=x;
			//先看左边
			int max;
			if(index>0)
			{
				data[x]++;
				max=heights[x-1];
				index--;
				while(index>0)
				{
					if(heights[x-1]<heights[index-1] && max<heights[index-1])
					{
						data[x]++;
						max=heights[index-1];
					}
					index--;
				}
			}
			
			//然后看右边
			index=x;
			if(index<heights.length-1)
			{
				data[x]++;
				index++;
				max=heights[x+1];
				while(index<heights.length-1)
				{
					if(heights[x+1]<heights[index+1]&& max<heights[index+1])
					{
						data[x]++;
						max =heights[index+1];
					}
					index++;
				}
			}
			
		}
		return data;
	}
	public static int[] findBuilding2(int[] heights)
	{
		Stack<Integer> stack1 = new Stack<>();
		int n = heights.length;
		int[] res = new int[n];
		Arrays.fill(res, 1); // 最起码能看到自己所在的这栋楼
		// 首先向左边看
		for (int i = 0; i < n - 1; i++)
		{ 
			// 只要当前楼大于等于前面遍历过的楼，
			//就把前面的矮楼丢掉，因为我站在该楼右边是看不到的
			while (!stack1.isEmpty() && heights[i] >= stack1.peek())
			{
				stack1.pop();
			}
			stack1.push(heights[i]);
			/*
			 *  这里i+1才是核心，
			 *  因为我已经通过while循环把比当前楼矮的都去掉了，
			 *  所以栈里剩下的都比当前楼高
			 *  也就是说当我站在该楼的右边一栋楼，栈里的楼我都能看到
			 */
			res[i + 1] += stack1.size();
		}
		Stack<Integer> stack2 = new Stack<>();
		for (int i = n - 1; i > 0; i--)
		{ // 然后向右边看
			while (!stack2.isEmpty() && heights[i] >= stack2.peek())
			{
				stack2.pop();
			}
			stack2.push(heights[i]);
			res[i - 1] += stack2.size(); // 同理
		}
		return res;
	}
	public static int[] findBuilding3(int[] heights)
	{
		int[] result =new int[heights.length];
		Arrays.fill(result, 1);//表示站在每一栋楼都能看到自己
		
		//先看左边的楼
		Stack<Integer> left =new Stack<Integer>();
		for(int x=0;x<heights.length-1;x++)
		{
			while(!left.isEmpty() && left.peek()<=heights[x])
			{
				left.pop();
			}
			left.push(heights[x]);
			result[x+1] += left.size();
		}
		//再看右边
		Stack<Integer> right =new Stack<Integer>();
		for(int x=heights.length-1;x>0;x--)
		{
			while(!right.isEmpty() && right.peek()<= heights[x])
			{
				right.pop();
			}
			right.push(heights[x]);
			result[x-1] +=right.size();
		}
		return result;
	}
}