1. 最近请求次数

写一个 RecentCounter 类来计算特定时间范围内最近的请求。

请实现 RecentCounter 类：

• RecentCounter() 初始化计数器，请求数为 0 。
• int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。

保证 每次对 ping 的调用都使用比之前更大的 t 值。

分析：

使用队列来模拟。每次输入t时把其插入队列中，因为每次对 ping 的调用都使用比之前更大的 t 值，所以只要从头开始遍历队列，当前值小于t-3000时把该值出队，出队后队列的大小即是要返回的值。

class RecentCounter {
    Queue<Integer> queue;

    public RecentCounter() {
        queue = new ArrayDeque<Integer>();
    }

    public int ping(int t) {
        queue.offer(t);
        while (queue.peek() < t - 3000) {
            queue.poll();
        }
        return queue.size();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 每日温度

请根据每日 气温 列表 temperatures ，重新生成一个列表，要求其对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。

分析：

使用单调栈来实现。用栈存储数组下标，在遍历数组当前温度比较栈顶温度过程中，若是温度越来越低，就一路存进栈内，碰到当前温度比栈顶温度高的就出栈并把结果数组栈顶对应的下标位置值设置为 当前温度的日期-栈顶温度的日期，一直出栈到栈顶下标的温度大于等于当前温度。

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        Stack<Integer> stack = new Stack<>();
        int[] res = new int[temperatures.length];
        stack.push(0);
        for (int i = 1; i < temperatures.length; i++) {
            while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]){
                int value = stack.pop();
                res[value] = i - value;
            }
            stack.push(i);
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3. 直方图最大矩形面积

给定非负整数数组 heights ，数组中的数字用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。求在该柱状图中，能够勾勒出来的矩形的最大面积。

分析：

使用单调栈来解决。单调栈的基本思想就是保证存在栈中的柱子的高度是递增的。基础操作为，从左往右扫描数组内的柱子高度，若当前柱高大于栈顶柱高，那么该柱子下标入栈；反之，将栈顶柱子出栈，并计算栈顶柱子为顶的最高矩阵面积，直至可入栈。
如何确定栈顶柱高为顶的最高矩阵面积？该矩阵的宽度一定是，从栈顶柱子的两边出发直到遇到比该柱高矮的柱子所夹成的宽度。因为单调栈中保存的柱高是递增的，所以栈中位于栈顶柱子前面的柱子一定比栈顶柱子矮，同样当前扫描到的柱子也矮于位于栈顶的柱子，所以顶柱子为顶的最高矩阵的宽度就确定了，那么面积也就确定了。

class Solution {
    public int largestRectangleArea(int[] heights) {
        int n = heights.length;
        int[] left = new int[n];
        int[] right = new int[n];
        Arrays.fill(right, n);
        
        Deque<Integer> mono_stack = new ArrayDeque<Integer>();
        for (int i = 0; i < n; ++i) {
            while (!mono_stack.isEmpty() && heights[mono_stack.peek()] >= heights[i]) {
                right[mono_stack.peek()] = i;
                mono_stack.pop();
            }
            left[i] = (mono_stack.isEmpty() ? -1 : mono_stack.peek());
            mono_stack.push(i);
        }
        
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans = Math.max(ans, (right[i] - left[i] - 1) * heights[i]);
        }
        return ans;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4. 矩阵中的最大矩形

给定一个由 0 和 1 组成的矩阵 matrix ，找出只包含 1 的最大矩形，并返回其面积。

注意：此题 matrix 输入格式为一维 01 字符串数组。

分析：

与上一题类似，也是要使用单调栈。因为最大矩阵一定是以矩阵的某一行为底边的，所以可以遍历各行寻找答案。以矩阵第一行为底的最大矩阵面积，等效于前一题中的直方图数组为 [1, 0, 1, 0, 0]；以第二行等效为 [2, 0, 2, 1, 1]；以第三行等效为 [3, 1, 3, 2, 2]；以第四行等效为 [4, 0, 0, 3, 0]；遍历完所有行，就能得到最大矩形的面积。注意一点，原矩阵内存的是字符。

class Solution {
    public int maximalRectangle(String[] matrix) {
        int m = matrix.length;
        if (m == 0) {
            return 0;
        }
        int n = matrix[0].length();
        int[][] left = new int[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i].charAt(j) == '1') {
                    left[i][j] = (j == 0 ? 0 : left[i][j - 1]) + 1;
                }
            }
        }

        int ret = 0;
        for (int j = 0; j < n; j++) { // 对于每一列，使用基于柱状图的方法
            int[] up = new int[m];
            int[] down = new int[m];

            Deque<Integer> stack = new ArrayDeque<Integer>();
            for (int i = 0; i < m; i++) {
                while (!stack.isEmpty() && left[stack.peek()][j] >= left[i][j]) {
                    stack.pop();
                }
                up[i] = stack.isEmpty() ? -1 : stack.peek();
                stack.push(i);
            }
            stack.clear();
            for (int i = m - 1; i >= 0; i--) {
                while (!stack.isEmpty() && left[stack.peek()][j] >= left[i][j]) {
                    stack.pop();
                }
                down[i] = stack.isEmpty() ? m : stack.peek();
                stack.push(i);
            }

            for (int i = 0; i < m; i++) {
                int height = down[i] - up[i] - 1;
                int area = height * left[i][j];
                ret = Math.max(ret, area);
            }
        }
        return ret;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

5. 求解方程

求解一个给定的方程，将x以字符串 “x=#value” 的形式返回。该方程仅包含 ‘+’ ， ‘-’ 操作，变量 x 和其对应系数。

如果方程没有解，请返回 “No solution” 。如果方程有无限解，则返回 “Infinite solutions” 。

题目保证，如果方程中只有一个解，则 ‘x’ 的值是一个整数。

分析：

遍历字符串模拟整个过程。使用变量 x 和 num 分别代指当前运算结果中 x 的系数以及数值部分，从前往后处理 s 的每个字符，根据字符类型进行分情况讨论，假设当前处理到的数值为 s[i]：

• 若 s[i] = +/-：此时影响的是下一个运算数值的正负，修改对应的 op 标识；
• 若 s[i] = 数值：此时将完整的运算值进行取出（运算值可能是关于 x 的描述，可能是纯数值），假设连续段 s[i:j−1] 之间为当前运算值，根据 s[j - 1] 是否为字符 x 可知，是要将 s[i:j−2] 的数值累加到变量 x，还是将 s[i:j−1] 的数值累加到变量 num；
• 若 s[i] = “=”：此时代表方程的左边已处理完，将变量 x 和 num 进行翻转（含义为将左边的运算结果移项到右边），并继续往后处理。
  当整个字符串 s 处理完后，得到最终关于 x 的系数 x，以及数值大小 num。根据 x 是否为 0 可知答案：
• 若 x 为 0：此时根据 num 是否为 0 可知是 Infinite solutions（对应 num 为 0） 还是 No solution（对应 num 不为 0）
• 若 x 不为 0：对 x 和 num 进行约分后，返回对应答案。

class Solution {
    public String solveEquation(String equation) {
        char[] chars = equation.toCharArray();
        int xNum = 0, num = 0, flag = 1;
        for (int i = 0; i < chars.length; ) {
            if (chars[i] == '+') {
                flag = 1;
                i++;
            }
            else if (chars[i] == '-'){
                flag = -1;
                i++;
            }
            else if (chars[i] == '='){
                xNum *= -1;
                num *= -1;
                flag = 1;
                i++;
            }
            else {
                int j = i;
                while (j<chars.length && chars[j]!='+' && chars[j]!='-' && chars[j]!='=') j++;
                if (chars[j-1] == 'x') xNum += (i<j-1?Integer.parseInt(equation.substring(i,j-1)):1)*flag;
                else num += Integer.parseInt(equation.substring(i,j))*flag;
                i = j;
            }
        }
        if (xNum == 0) return num == 0?"Infinite solutions":"No solution";
        else return "x="+num/-xNum;

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33