【公司真题--腾讯】腾讯2020校园招聘-后台

1.压缩算法

主要思路就是类似于用栈求后缀表达式，主要收获就是类似这种表达式的题目可以用栈解决
1.遇到’]‘，就往里找这个[2|ABC]，然后替换
2.除了’]'，其他的字符就入栈

代码实现中有两个很重要的注意点：
1.从栈中取出来的字符串都需要反转
2.[3|ABC] 3这个数字不一定是一位，所以要注意取到[为止，取值1-100

import java.util.*;

public class Solution {
    public String compress (String str) {
        //HG[3|B[2|CA]]F−>HG[3|BCACA]F−>HGBCACABCACABCACAF
        //[3|ABC]->ABCABCABC
        //str包含四种字符：[ ] | 大写字母
        LinkedList<Character> stack = new LinkedList<>();
        for(char c : str.toCharArray()){
            //入栈
            if(c!=']') {stack.addLast(c); continue;}
            //找到并且删除"ABC"
            String t = "";
            while(stack.getLast()!='|'){
                t = t + String.valueOf(stack.removeLast());
            }
            //注意点1：这时候t是CBA记得反过来
            t = (new StringBuilder(t)).reverse().toString();
            //删除'|'
            stack.removeLast();
            //删除并且获得数字3
            //注意点2：这个数字不一定是1位的 这个数字[1,100] 最多三位应该是
            //int cnt = Integer.parseInt(String.valueOf(stack.removeLast()));
            String cntStr = "";
            while(stack.getLast()!='['){
                cntStr = cntStr + String.valueOf(stack.removeLast());
            }
            cntStr = (new StringBuilder(cntStr)).reverse().toString();
            int cnt = Integer.parseInt(cntStr);
            //删除'['
            stack.removeLast();
            //添加cnt个t
            while(cnt-->0){
                for(char item : t.toCharArray()) stack.addLast(item);
            }
        }
        StringBuilder ans = new StringBuilder();
        for(char c : stack) ans.append(c);
        return ans.toString();
    }
}

2.逛街

双单调栈的思想：

import java.util.*;

public class Solution {
    public int[] findBuilding (int[] heights) {
        //[5,3,8,3,2,5]
        //[3,3,5,4,4,4]
        //每一个数字 左右开始递增的个数加起来 双单调栈解决
        int len = heights.length;

        //1.统计[0,1,2..i+1] i+1往左边看能看到的数量==[0,i]闭区间单调递减栈最终的大小
        int[] left = new int[len];
        LinkedList<Integer> left_stack = new LinkedList<>();
        left_stack.addLast(Integer.MAX_VALUE);
        for(int i=0;i<=len-2;i++){
            while(heights[i]>=left_stack.getLast()) left_stack.removeLast();
            left_stack.addLast(heights[i]);
            left[i+1] = left_stack.size()-1;
        }
        //2.统计[i-1,i..len-1] i-1往右边看能看到的数量==[i+1,len-1]闭区间单调递减栈最终的大小
        int[] right = new int[len];
        LinkedList<Integer> right_stack = new LinkedList<>();
        right_stack.addLast(Integer.MAX_VALUE);
        for(int i=len-1;i>=1;i--){
            while(heights[i]>=right_stack.getLast()) right_stack.removeLast();
            right_stack.addLast(heights[i]);
            right[i-1] = right_stack.size()-1;
        }
        //3.加起来并且加本身
        int[] ans = new int[len];
        for(int i=0;i<len;i++) ans[i] = left[i]+right[i]+1;
        return ans;
    }
}

3.逆序对

4.假期

5.视野争夺