栈与队列 on Coder_Studio

BISHI51 低买高卖

Sun, 15 Feb 2026 20:24:29 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());

        String[] str = br.readLine().split("\\s+");

        long[] p = new long[n];

        for (int i = 0; i < n; i++) {
            p[i] = Long.parseLong(str[i]);
        }
        PriorityQueue<Long> minHeap = new PriorityQueue<>(); // 小顶堆：堆顶始终是当前堆中最小值
        long profit = 0; // 初始化总利润为0

        for (int i = 0; i < n; i++) {
            minHeap.add(p[i]); // 将当前价格加入堆
            if (minHeap.peek() < p[i]) { // 如果堆顶（当前最低价格）< 当前价格 → 可以低买高卖
                long buy = minHeap.poll(); // 取出堆顶（买入价）
                profit += p[i] - buy; // 累加本次利润（当前价-买入价）
                minHeap.add(p[i]); // 把当前价格重新入堆（相当于“卖出后再以当前价买入”，继续后续交易）
            }
        }
        out.println(profit);
        out.flush();
        out.close();
        br.close();

    }

BISHI50 [JSOI2007]建筑抢修

Sun, 15 Feb 2026 00:47:10 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int n = Integer.parseInt(br.readLine());
        // 存储每个建筑的维修耗时t和报废时限d
        int[][] buildings = new int[n][2];

        for (int i = 0; i < n; i++) {
            String[] numStr = br.readLine().split("\\s+");
            buildings[i][0] = Integer.parseInt(numStr[0]);
            buildings[i][1] = Integer.parseInt(numStr[1]);
        }
        // 按报废时限d_i升序排序（优先处理时限早的）
        Arrays.sort(buildings, (a, b) -> a[1] - b[1]);

        // 初始化最大堆（存储已选建筑的耗时，优先弹出最大值）
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        long total = 0; // 当前累计维修时间

        for (int[] b : buildings) {

            int t = b[0];
            int d = b[1];
            // 加入当前建筑，累计时间
            maxHeap.add(t);
            total += t;
            // 若累计时间超过当前建筑的时限，移除耗时最长的建筑
            if (total > d) {
                int removeT = maxHeap.poll();
                total -= removeT;
            }

        }
        // 堆的大小即为最多可维修的建筑数量
        out.println(maxHeap.size());

        out.flush();
        out.close();
        br.close();
    }

BISHI49 小红闯关

Sun, 15 Feb 2026 00:11:29 +0000

思路

求解代码

 public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        String[] str = br.readLine().split("\\s+");
        int n = Integer.parseInt(str[0]);
        int k = Integer.parseInt(str[1]);

        String[] numStr = br.readLine().split("\\s+");
        long[] a = new long[n];
        long total = 0;

        for (int i = 0; i < n; i++) {
            a[i] = Long.parseLong(numStr[i]);
            total += a[i];// 累加总耗时
        }
        // 初始化最大堆（优先队列），用于存储可跳过的关卡耗时（优先弹出最大值）
        // PriorityQueue默认是最小堆，Collections.reverseOrder()转为最大堆
        PriorityQueue<Long> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        long saveTime = 0;

        for (int i = n - 1; i >= 0; i--) {
            // (i+1)表示"已通过前i+1个关卡"（按顺序），满足每k个关卡则获得1个道具
            // 0-based索引转1-based计数，确保规则匹配
            if ((i + 1) % k == 0 && !maxHeap.isEmpty()) {
                // 获得道具，跳过堆中耗时最大的关卡，累加跳过的耗时
                saveTime += maxHeap.poll();
            }
            // 最小总耗时 = 全通关耗时 - 跳过的最大耗时之和
            maxHeap.add(a[i]);
        }

        out.println(total - saveTime);

        out.flush();
        out.close();
        br.close();
    }

【ACM模式】队列操作

Wed, 04 Feb 2026 19:46:59 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        Deque<Integer> queue = new ArrayDeque<>();
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            int n = (int) in.nval;

            for (int i = 0; i < n; i++) {
                in.nextToken();
                int a = (int) in.nval;

                switch (a) {
                    case 1:
                        in.nextToken();
                        queue.add((int) in.nval);
                        break;
                    case 2:
                        if (queue.isEmpty()) {
                            out.println("ERR_CANNOT_POP");
                        } else {
                            queue.pollFirst();
                        }
                        break;
                    case 3:
                        if (queue.isEmpty()) {
                            out.println("ERR_CANNOT_QUERY");
                        } else {
                            out.println(queue.peekFirst());
                        }
                        break;
                    case 4:
                        out.println(queue.size());
                        break;
                    default:
                        break;
                }
            }
        }
        out.flush();
        out.close();
    }

【ACM模式】栈的操作

Wed, 04 Feb 2026 18:02:20 +0000

求解代码

public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        Deque<Integer> stack = new ArrayDeque<>();
        in.nextToken();
        int n = (int)in.nval;
        for(int i=0;i<n;i++){
            in.nextToken();
            String str = (String)in.sval;
            switch (str) {
                case "push":
                    in.nextToken();
                    stack.push((int)in.nval);
                    break;
                case "pop":
                    if(stack.isEmpty()){
                        out.println("Empty");
                    }else{
                        stack.pop();
                    }
                    break;
                case "query":
                    if(stack.isEmpty()){
                        out.println("Empty");
                    }else{
                        out.println(stack.peek());
                    }
                    break;
                case "size":
                    out.println(stack.size());
                    break;                                                     
                default:
                    break;
            }
        }
        out.flush();
        out.close();
    }

小贴士

官方文档明确标注：

Deque接口及其实现类（如ArrayDeque）应优先于Stack类使用。

【优先级队列】主持人调度（二）

Tue, 27 Jan 2026 23:08:23 +0000

求解代码

public int minmumNumberOfHost (int n, int[][] startEnd) {
        Arrays.sort(startEnd,(a,b)->{
            if(a[0]==b[0]){
                return Integer.compare(a[1], b[1]);
            }
            return Integer.compare(a[0], b[0]);
        });

        PriorityQueue<Integer> queue = new PriorityQueue<>();
        int maxHost = 0;
        for(int[] activity:startEnd){
            while(!queue.isEmpty()&&queue.peek()<=activity[0]){
                queue.poll();
            }

            queue.offer(activity[1]);
            maxHost = Math.max(maxHost,queue.size());
        }
        return maxHost;
    }

踩坑记录

❌1.排序比较器整数溢出

1
2
3

Arrays.sort(startEnd, (a, b) ->
    (a[0] == b[0] ? b[1] - a[1] : a[0] - b[0])
);

❌2.返回值不能返回最后的堆大小

`1`	`return queue.size(); //`

因为题目要的是整个过程中，堆出现过的最大大小。

❌3.释放主持人只用 if可能不够

1
2
3

if (queue.peek() <= activity[0]) {
    queue.poll();
}

因为实际情况下可能有多个活动已经结束。

单调队列-滑动窗口的最大值

Thu, 15 Jan 2026 21:58:40 +0000

求解代码

class MonotonicQueue {
        LinkedList<Integer> queue = new LinkedList<>();
        public void push(int n){
            while(!queue.isEmpty()&&queue.getLast()<n){
                queue.pollLast();
            }
            queue.addLast(n);
        }

        public void pop(int n){
            if(n==queue.getFirst()){
                queue.pollFirst();
            }
        }

        public int max(){
            return queue.getFirst();
        }

    }
    public ArrayList<Integer> maxInWindows (int[] num, int size) {

        MonotonicQueue window = new MonotonicQueue();

        ArrayList<Integer> res = new ArrayList<>();        
        if(num==null||size<=0||num.length==0||size>num.length){
            return res;
        }


        for(int i=0;i<num.length;i++){
            if(i<size-1){
                window.push(num[i]);
            }else{
                window.push(num[i]);
                res.add(window.max());
                window.pop(num[i-size+1]);
            }
        }
        return res;
    }

小贴士

1.构建一个特殊的【单调队列】来充当不断滑动的窗口：

这个单调队列的队首记录了滑动过程中的最大值（对应max方法），从队首到队尾的元素值大小是单调递减的；

当队列为空或者尾部的元素（getLast）小于要入队的元素时，将该尾部元素弹出（pollLast）,元素是从队列尾部入队的（addLast）。

当滑动窗口需要移除的元素等于队列头部（当前最大值）时，将队首元素弹出（pollFirst）；

2.解释一下这个i-size+1

对于长度固定为size的滑动窗口，当窗口还没填满时，不考虑计算最大值和移除元素，直到把前size-1个元素填满；

从第size个元素开始（对应就是下标size-1），窗口正式填满，此时，依次完成把当前元素加入窗口，将窗口的最大值记录到res中，再把窗口最左侧的元素移除，为下一步滑动腾出一个位置。

那窗口最左侧元素的下标是什么呢？

因为当前元素是num[i]，所以此时的窗口的右边界是i，又因为窗口的大小固定为size，所以，窗口的左边界就是i-size+1，这也就是我们要移除的窗口最左侧元素的下标。

有效括号序列

Thu, 15 Jan 2026 20:28:38 +0000

求解代码

public boolean isValid (String s) {
        char[] str = s.toCharArray();

        Stack<Character> stackData = new Stack<>();

        for(char c:str){
            if(c=='('){
                stackData.push(')');
            }else if(c=='['){
                stackData.push(']');
            }else if(c=='{'){
                stackData.push('}');
            }else if(stackData.isEmpty()||c!=stackData.pop()){
                return false;
            }
        }
        return stackData.isEmpty();
    }

小贴士

如果遇到了左括号，就把和这个左括号配对的右括号压入栈中，总共就3种括号：小括号、中括号和花括号；

如果遇到了右括号，分情况讨论：

如果此时栈为空，说明无法构成有效的括号；
如果此时栈不为空，并且出栈的元素不等于这个右括号；

这两种情况，都构不成有效的括号，返回false；

只有到最后栈为空了，才返回true。

包含min函数的栈

Thu, 15 Jan 2026 20:04:19 +0000

求解代码

Stack<Integer> stackData1 = new Stack<Integer>();
    Stack<Integer> stackData2 = new Stack<Integer>();


    public void push(int node) {
        stackData1.push(node);
        if(stackData2.isEmpty()||node<=min()){
            stackData2.push(node);
        }
    }
    
    public void pop() {
        if(stackData1.peek().equals(min())){
            stackData2.pop();
        }
        stackData1.pop();
    }
    
    public int top() {
        return stackData1.peek();
    }
    
    public int min() {
        return stackData2.peek();
    }

小贴士

用 stackData1.peek().equals(min()) 来比较包装类的实际数值，也可以用 stackData1.peek().intValue() == min()，效果是一样的。

用两个栈实现队列

Thu, 15 Jan 2026 00:14:18 +0000

求解代码

Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if(stack2.isEmpty()){
            while (!stack1.isEmpty()) {
                stack2.push(stack1.pop());
            }
        } 
        return stack2.pop();
    }

小贴士

所有入队的元素，无条件直接压入 stack1
stack1 只管入队，stack2 只管出队，并且只有当stack2 为空时才进行一次性倒栈

并查集的实现

Sat, 03 Jan 2026 19:04:18 +0000

代码求解

father数组：每个集合元素往上的指针，下标对应节点编号，初始时每个节点指向自己。

size数组：记录每个集合的大小，初始时每个集合大小为1。

stack数组：用于扁平化过程中收集沿途节点。

public static int MAXN = 1000001;
	public static int[] father = new  int[MAXN];
	public static int[] size = new int[MAXN];
	public static int[] stack = new int[MAXN];

	public static int n;

	public static void build(){
		for(int i=0;i<=n;i++){
			father[i]=i;
			size[i]=i;
		}
	}

	public static int find(int i){
		int size = 0;
		while (i!=father[i]) {
			stack[size++]=i;
			i=father[i];
		}

		while (size>0) {
			father[stack[--size]]=i;
		}

		return i;
	}

	public static boolean isSameSet(int x,int y){
		return find(x)==find(y);
	}

	public static void union(int x,int y){
		int fx = find(x);
		int fy = find(y);

		if (fx!=fy) {
			if(size[fx]>=size[fy]){
				size[fx]+=size[fy];
				father[fy]=fx;
			}else{
				size[fy]+=size[fx];
				father[fx]=fy;
			}
		}
	}

	public static void main(String[] args)throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

		while (in.nextToken()!=StreamTokenizer.TT_EOF) {
			n = (int)in.nval;
			build();
			in.nextToken();
			int m = (int)in.nval;

			for(int i=0;i<m;i++){
				in.nextToken();
				int op = (int)in.nval;
				in.nextToken();
				int x = (int)in.nval;
				in.nextToken();
				int y = (int)in.nval;
				if(op==1){
					out.println(isSameSet(x, y)?"Yes":"No");
				}else{
					union(x, y);
				}
			}
		}
		out.flush();
		out.close();
		br.close();
	}

Leetcode1499满足不等式的最大值

Fri, 02 Jan 2026 23:20:11 +0000

问题分析

双端队列按照y-x的值从大到小组织，队列中存储点的编号。

如果y-x的值大于队列尾部元素的y-x值，则从尾部弹出元素。

如果当前点的x值与队列头部元素的x值之差大于k时，则从头部弹出元素。

求解代码

public static int MAXN = 100001;
	public static int[][] deque = new int[MAXN][2];
	public static int h,t;

	public static int findMaxValueOfEquation(int[][] points,int k){
		h = t = 0;
		int n = points.length;
		int ans = Integer.MIN_VALUE;
		for(int i=0,x,y;i<n;i++){
			x=points[i][0];
			y=points[i][1];

			while (h<t&&deque[h][0]+k<x) {
				h++;
			}

			if(h<t){
				ans = Math.max(ans, x+y+deque[h][1]-deque[h][0]);
			}

			while (h<t&&deque[t-1][1]-deque[t-1][0]<=y-x) {
				t--;
			}

			deque[t][0]=x;
			deque[t++][1]=y;
		}
		return ans;
	}

Leetcode862和至少为K的最短子数组

Thu, 01 Jan 2026 21:49:49 +0000

题目分析

遍历数组，对于每个位置i，假设子数据必须以i作为右边界，求出往左延伸多短，能够让累加和大于等于K，最后从所有答案中选择最小值。

准备一个双端队列，要求从头到尾严格小到大。当来到位置i，0~i范围的前缀和为x时，从头部依次考察，如果x减去队列头部指示的前缀和达标，则记录答案并将头部元素弹出，因为后续位置使用该前缀和得到的结果不会更短。

加入新的前缀和时，如果不满足队列小到大的顺序，则从尾部弹出元素。

求解代码

public static int MAXN = 100001;
	public static long[] sum = new long[MAXN];
	public static int[] deque = new int[MAXN];
	public static int h,t;
	public static int shortestSubarray(int[] arr,int K){
		int n = arr.length;
		for(int i = 0;i<n;i++){
			sum[i+1]=sum[i]+arr[i];
		}
		h=t=0;
		int ans = Integer.MAX_VALUE;
		for(int i=0;i<=n;i++){
			while (h!=t&&sum[i]-sum[deque[h]]>=K) {
				ans = Math.min(ans, i-deque[h++]);
			}

			while (h!=t&&sum[deque[t-1]]>=sum[i]) {
				t--;
			}
			deque[t++]=i;
		}
		return ans!=Integer.MAX_VALUE?ans:-1;
	}

Leetcode239滑动窗口最大值

Wed, 31 Dec 2025 21:20:32 +0000

求解代码

准备一个数组作为双端队列deque，用h（head）和t（tail）表示队列的头和尾位置。

双端队列要维持从左往右大到小的顺序。

public static int MAXN = 100001;
	public static int[] deque = new int[MAXN];
	public static int h,t;
	public static int[] maxSlidingWindow(int[] arr,int k){
		h = t = 0;
		int n = arr.length;
		for(int i=0;i<k-1;i++){
			while(h<t&&arr[deque[t-1]]<=arr[i]){
				t--;
			}
			deque[t++]=i;
		}

		int m = n-k+1;
		int[] ans = new int[m];
		for(int l=0,r=k-1;l<m;l++,r++){
			while(h<t&&arr[deque[t-1]]<=arr[r]){
				t--;
			}
			deque[t++]=r;
			ans[l]=arr[deque[h]];
			if(deque[h]==l){
				h++;
			}
		}
		return ans;
	}

单调栈-大鱼吃小鱼问题

Tue, 30 Dec 2025 22:03:56 +0000

代码求解

栈是一个n*2的二维数组，每个元素包含两个数，0位置的是体重，1位置的是轮数。

	public static int MAXN = 100001;
	public static int[] arr = new int[MAXN];
	public static int n;
	public static int[][] stack = new int[MAXN][2];
	public static int r;

	public static void main(String[] args)throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

		while(in.nextToken()!=StreamTokenizer.TT_EOF){
			n = (int)in.nval;
			for(int i=0;i<n;i++){
				in.nextToken();
				arr[i]=(int)in.nval;
			}
			out.println(turns());
		}
		out.flush();
		out.close();
		br.close();
	}

	public static int turns(){
		r = 0;
		int ans  = 0;
		for(int i=n-1,curTurns;i>=0;i--){
			curTurns = 0;
			while(r>0&&stack[r-1][0]<arr[i]){
				curTurns = Math.max(curTurns+1, stack[--r][1]);
			}
			stack[r][0]=arr[i];
			stack[r++][1]=curTurns;
			ans = Math.max(ans, curTurns);
		}
		return ans;
	}

Leetcode316去除重复字母

Tue, 30 Dec 2025 21:08:58 +0000

求解思路

构建大压小的单调栈。

建立词频表，统计字符串中每种字符出现的次数。

新字符入栈时，如果破坏了大压小的原则，看栈顶元素对应的字符在后面是否还有，如果有则栈顶元素出栈，新字符入栈；

如果栈里已有该字符，则直接跳过。

代码实现

	public static int MAXN = 26;
	public static int[] cnts = new int[MAXN];
	public static boolean[] enter = new boolean[MAXN];
	public static char[] stack = new char[MAXN];
	public static int r;

	public static String removeDuplicateLetters(String str){
		r=0;
		Arrays.fill(cnts, 0);
		Arrays.fill(enter, false);

		char[] s = str.toCharArray();
		for(char cha:s){
			cnts[cha-'a']++;
		}

		for(char cur:s){
			if(!enter[cur-'a']){
				while(r>0&&stack[r-1]>cur&&cnts[stack[r-1]-'a']>0){
					enter[stack[r-1]-'a']=false;
					r--;
				}
				stack[r++]=cur;
				enter[cur-'a']=true;
			}
			cnts[cur-'a']--;
		}
		return String.valueOf(stack,0,r);
	}

Leetcode962最大宽度坡

Tue, 30 Dec 2025 20:05:05 +0000

问题分析

这道题采用小压大的单调栈求解。

从左往右遍历数组，只有依次小压大这种下降趋势的下标才有必要收集进单调栈。

收集完单调栈后，从右往左遍历数组。

假设当前的右侧位置为最右下标，依次看其与栈中的左侧下标是否能构成坡。

如果可以构成，则计算宽度并更新最大宽度答案，同时弹出该左侧下标。

初始化栈的时候，栈的大小为1，相当于是把0下标放入栈中。

求解代码

	public static int MAXN = 50001;
	public static int[] stack = new int[MAXN];
	public static int r;
	public static int maxWidthRamp(int[] arr){
		r =1;
		int n = arr.length;
		for(int i=1;i<n;i++){
			if(arr[stack[r-1]]>arr[i]){
				stack[r++]=i;
			}
		}
		int ans = 0;
		for(int j=n-1;j>=0;j--){
			while(r>0&& arr[stack[r-1]]<=arr[j]){
				ans = Math.max(ans,j-stack[--r]);
			}
		}
		return ans;
	}

单调栈-柱状图中的最大矩形

Mon, 29 Dec 2025 23:26:48 +0000

代码求解

对于直方图中的每个高度，找到其左右两侧离它最近且比它小的高度位置，以该高度为高向左右两侧拓展，计算拓展的单位数，再乘以该高度得到长方形面积，对每个高度进行遍历，求得最大值。

虽然高度相等的时候弹出的计算结果可能是错误的，但总是会有最后一个相同高度能够算对，所以并不会影响最终求解的最大长方形的面积。

class Solution {
    	public static int MAXN = 100001;
	public static int[] stack = new int[MAXN];
	public static int r;

	public static int largestRectangleArea(int[] height){
		int n = height.length;
		r = 0;
		int ans = 0,cur,left;
		for(int i = 0;i<n;i++){
			while(r>0&&height[stack[r-1]]>=height[i]){
				cur = stack[--r];
				left = r==0?-1:stack[r-1];
				ans = Math.max(ans, height[cur]*(i-left-1));
			}
			stack[r++]=i;
		}

		while (r>0) {
			cur = stack[--r];
			left = r==0?-1:stack[r-1];
			ans = Math.max(ans, height[cur]*(n-left-1));
		}
		return ans;
	}
}

单调栈-子数组的最小值之和

Mon, 29 Dec 2025 22:27:43 +0000

代码求解

利用严格的大压小单调栈，找到每个位置数字左右两边离它最近且比它小的数字，确定以该数字为最小值的子数组的范围，通过计算开头和结尾的可能性确定字数租的个数，乘以该数字得到这部分子数组的最小值之和，每个数在弹出的时候都需要计算答案。

class Solution {
    public static int MAXN = 30001;
	public static int MOD = 1000000007;
	public static int[] stack = new int[MAXN];
	public static int r;

	public static int sumSubarrayMins(int[] arr){
		long ans = 0;
		for(int i=0;i<arr.length;i++){
			while(r>0&&arr[stack[r-1]]>=arr[i]){
				int cur = stack[--r];
				int left = r==0?-1:stack[r-1];
				ans = (ans+(long)(cur-left)*(i-cur)*arr[cur])%MOD;
			}
			stack[r++]=i;
		}

		while(r>0){
			int cur = stack[--r];
			int left = r==0?-1:stack[r-1];
			ans = (ans+(long)(cur-left)*(arr.length-cur)*arr[cur])%MOD;
		}
		return (int)ans;
	}
}

单调栈-Leetcode739每日温度

Mon, 29 Dec 2025 21:31:19 +0000

代码求解

求更高温度出现在几天后，这是一个严格大于的问题，需要使用小压大的单调栈。

class Solution {
    public static int MAXN = 100001;

	public static int[] stack = new int[MAXN];

	public static int r;

	public static int[] dailyTemperatures(int[] nums){
		int n = nums.length;
		int[] ans = new int[n];
		r = 0;
		for(int i=0,cur;i<n;i++){
			while (r>0&&nums[stack[r-1]]<nums[i]) {
				cur = stack[--r];
				ans[cur]=i-cur;
			}
			stack[r++]=i;
		}
		return ans;
	}
}

单调栈结构进阶题

Mon, 29 Dec 2025 20:57:49 +0000

求解代码

main 方法

	public static int MAXN = 1000001;

	public static int[] arr = new int[MAXN];

	public static int[] stack = new int[MAXN];

	public static int[][] ans = new int[MAXN][2];

	public static int n,r;

	public static void main(String[] args)throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StreamTokenizer in = new StreamTokenizer(br);
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

		while(in.nextToken()!=StreamTokenizer.TT_EOF){
			n = (int)in.nval;
			for(int i=0;i<n;i++){
				in.nextToken();
				arr[i]=(int)in.nval;
			}
			compute();
			for(int i=0;i<n;i++){
				out.println(ans[i][0]+ " " + ans[i][1]);
			}
		}
		out.flush();
		out.close();
		br.close();
	}

compute 方法

整体来看就是三步走，先遍历，后清算，再修正。

用数组实现栈，变量r表示栈的使用情况，栈中存放的是数组的下标。

r=0时，即栈为空时，当前的遍历位置i直接入栈。

依次比较栈顶以及栈顶以下的元素对应的值和arr[i]的大小，如果大于等于arr[i]。

出栈后，如果栈为空，则左侧答案为-1，非空的话，左侧答案就是栈顶压着的那个元素；右侧答案就是让其出站的i位置。

如果遍历结束后，栈中还有元素，还需要依次弹出，也就是清算。

弹出元素的左侧答案，如果栈为空，则左侧答案为-1，非空的话，左侧答案就是栈顶压着的那个元素；右侧答案一律为-1。

考虑到存在相等的值，因此，还需要进行修正。

因为n-1位置右侧的答案一定是-1，所以无需修正。

如果右侧的答案不是-1，并且答案位置对应的值和当前位置对应的值相等，则将答案位置的右侧答案作为当前位置的右侧答案，这里可能有点拗口，但是仔细想想应该可以理解。

public static void compute(){
		r = 0;
		int cur;
		for(int i = 0;i<n;i++){
			while(r>0&&arr[stack[r-1]]>=arr[i]){
				cur = stack[--r];

				ans[cur][0]=r>0?stack[r-1]:-1;
				ans[cur][1]=i;
			}
			stack[r++]=i;
		}
		while(r>0){
			cur = stack[--r];
			ans[cur][0]=r>0?stack[r-1]:-1;
			ans[cur][1]=-1;
		}

		for(int i=n-2;i>=0;i--){
			if(ans[i][1]!=-1&&arr[ans[i][1]]==arr[i]){
				ans[i][1]=ans[ans[i][1]][1];
			}
		}
	}

最大频率栈

Sat, 25 Oct 2025 19:52:07 +0000

代码逻辑

这道题的关键在于：如何同时维护频率信息和时间顺序？

我们可以把栈想象成一个"蛋糕"，按频率分层：

第 1 层：存放所有出现过 1 次的元素
第 2 层：存放所有出现过 2 次的元素
第 3 层：存放所有出现过 3 次的元素
…

每当一个元素被 push 进来，它的频率加 1然后它会被添加到对应频率的那一层。

每当执行 pop 操作，从最高层（最大频率层）取出最后一个元素，如果该层变空，层数减 1。

1.数据结构设计

class FreqStack {
    // 当前最大频率
    private int topTimes;
    
    // 分层存储：频率 -> 该频率下的元素列表
    private HashMap<Integer, ArrayList<Integer>> cntValues= new HashMap<>();
    
    // 元素计数：元素值 -> 出现次数
    private HashMap<Integer, Integer> valueTimes== new HashMap<>();
}

2.push 操作

public void push(int val) {
    // 更新该元素的频率
    valueTimes.put(val, valueTimes.getOrDefault(val, 0) + 1);
    int curTopTimes = valueTimes.get(val);
    
    // 将元素添加到对应频率层
    if (!cntValues.containsKey(curTopTimes)) {
        cntValues.put(curTopTimes, new ArrayList<>());
    }
    ArrayList<Integer> curTimeValues = cntValues.get(curTopTimes);
    curTimeValues.add(val);
    
    // 更新最大频率
    topTimes = Math.max(topTimes, curTopTimes);
}

3.pop 操作

public int pop() {
    // 从最高层取出最后一个元素
    ArrayList<Integer> topTimeValues = cntValues.get(topTimes);
    int ans = topTimeValues.remove(topTimeValues.size() - 1);
    
    // 如果该层变空，删除该层并降低最高频率
    if (topTimeValues.size() == 0) {
        cntValues.remove(topTimes--);
    }
    
    // 更新元素的频率计数
    int times = valueTimes.get(ans);
    if (times == 1) {
        valueTimes.remove(ans);
    } else {
        valueTimes.put(ans, times - 1);
    }
    
    return ans;
}

完整代码

class FreqStack{
        // 当前最大频率
        private int topTimes;

        // 分层存储：频率 -> 该频率下的元素列表
        private HashMap<Integer, ArrayList<Integer>> cntValues= new HashMap<>();

        // 元素计数：元素值 -> 出现次数
        private HashMap<Integer, Integer> valueTimes= new HashMap<>();

        public void push(int val) {
            // 更新该元素的频率
            valueTimes.put(val, valueTimes.getOrDefault(val, 0) + 1);
            int curTopTimes = valueTimes.get(val);

            // 将元素添加到对应频率层
            if (!cntValues.containsKey(curTopTimes)) {
                cntValues.put(curTopTimes, new ArrayList<>());
            }
            ArrayList<Integer> curTimeValues = cntValues.get(curTopTimes);
            curTimeValues.add(val);

            // 更新最大频率
            topTimes = Math.max(topTimes, curTopTimes);
        }

        public int pop() {
            // 从最高层取出最后一个元素
            ArrayList<Integer> topTimeValues = cntValues.get(topTimes);
            int ans = topTimeValues.remove(topTimeValues.size() - 1);

            // 如果该层变空，删除该层并降低最高频率
            if (topTimeValues.size() == 0) {
                cntValues.remove(topTimes--);
            }

            // 更新元素的频率计数
            int times = valueTimes.get(ans);
            if (times == 1) {
                valueTimes.remove(ans);
            } else {
                valueTimes.put(ans, times - 1);
            }

            return ans;
        }
    }

关注我，带你深度剖析更多经典算法题！ 🚀