数据结构与算法（Java） -单调队列单调栈题单

最新推荐文章于 2024-03-10 14:57:21 发布
最新推荐文章于 2024-03-10 14:57:21 发布
阅读量1k 收藏 24
点赞数 15
分类专栏： leetcode题单系列 文章标签： java 算法 数据结构 笔记 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fffffall/article/details/134761765
版权

单调队列（灵神笔记）

239 滑动窗口最大值

239. 滑动窗口最大值 - 力扣（LeetCode）

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

示例 2：

输入：nums = [1], k = 1
输出：[1]

提示：

  • 1 <= nums.length <= 105
  • -104 <= nums[i] <= 104
  • 1 <= k <= nums.length
class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        /*示例1 队列的变化
        * 1. 1  2. 3    3. 3 -1 -3  4. 5    5. 5 3  6. 6    7. 7
        * 注意如果是第3步 将2加入队列 滑动窗口长度(i-队首下标)大于3 删除队首元素
        * 保证队首元素为滑动窗口最大值 队列单调递减
        */ 
        int n = nums.length;
        int[] ans = new int[n - k + 1];
        Deque<Integer> d = new ArrayDeque<>();
        for (int i = 0; i < n; i++) {
            //进
            while (!d.isEmpty() && nums[i] >= nums[d.peekLast()]) {
                d.pollLast();
            }
            d.addLast(i);
            //出
            if (i - d.peekFirst() >= k) {
                d.pollFirst();
            }
            //更新答案
            if (i >= k - 1) {
                ans[i - k + 1] = nums[d.peekFirst()];
            }
        }
        return ans;
    }
}

1438 绝对差不超过限制的最长连续子数组

1438. 绝对差不超过限制的最长连续子数组 - 力扣（LeetCode）

给你一个整数数组 nums ，和一个表示限制的整数 limit，请你返回最长连续子数组的长度，该子数组中的任意两个元素之间的绝对差必须小于或者等于 limit 。

如果不存在满足条件的子数组，则返回 0 。

示例 1：

输入：nums = [8,2,4,7], limit = 4
输出：2 
解释：所有子数组如下：
[8] 最大绝对差 |8-8| = 0 <= 4.
[8,2] 最大绝对差 |8-2| = 6 > 4. 
[8,2,4] 最大绝对差 |8-2| = 6 > 4.
[8,2,4,7] 最大绝对差 |8-2| = 6 > 4.
[2] 最大绝对差 |2-2| = 0 <= 4.
[2,4] 最大绝对差 |2-4| = 2 <= 4.
[2,4,7] 最大绝对差 |2-7| = 5 > 4.
[4] 最大绝对差 |4-4| = 0 <= 4.
[4,7] 最大绝对差 |4-7| = 3 <= 4.
[7] 最大绝对差 |7-7| = 0 <= 4. 
因此，满足题意的最长子数组的长度为 2 。

示例 2：

输入：nums = [10,1,2,4,7,2], limit = 5
输出：4 
解释：满足题意的最长子数组是 [2,4,7,2]，其最大绝对差 |2-7| = 5 <= 5 。

示例 3：

输入：nums = [4,2,2,2,4,4,2,2], limit = 0
输出：3

提示：

  • 1 <= nums.length <= 10^5
  • 1 <= nums[i] <= 10^9
  • 0 <= limit <= 10^9
class Solution {
    public int longestSubarray(int[] nums, int limit) {
        //利用两个双端队列，max从左到右单调递增，队首为最大值，min相反
        Deque<Integer> maxdeque = new ArrayDeque<>();
        Deque<Integer> mindeque = new ArrayDeque<>();
        int n = nums.length;
        int right = 0, left = 0, ans = 0;
        //枚举right
        while (right < n) {
            while (!maxdeque.isEmpty() && nums[right] > maxdeque.peekLast()) {
                maxdeque.removeLast();
            }
            while (!mindeque.isEmpty() && nums[right] < mindeque.peekLast()) {
                mindeque.removeLast();
            }
            maxdeque.addLast(nums[right]);
            mindeque.addLast(nums[right]);
            //移动left
            while (maxdeque.peekFirst() - mindeque.peekFirst() > limit) {
                //更新队内元素
                if (maxdeque.peekFirst() == nums[left]) {
                    maxdeque.removeFirst();
                }
                if (mindeque.peekFirst() == nums[left]) {
                    mindeque.removeFirst();
                }
                left++;
            }
            ans = Math.max(ans, right - left + 1);
            right++;
        }
        return ans;
    }
}

2398 预算内的最多机器人数目

2398. 预算内的最多机器人数目 - 力扣（LeetCode）

你有 n 个机器人，给你两个下标从 0 开始的整数数组 chargeTimes 和 runningCosts ，两者长度都为 n 。第 i 个机器人充电时间为 chargeTimes[i] 单位时间，花费 runningCosts[i] 单位时间运行。再给你一个整数 budget 。

运行 k 个机器人 总开销 是 max(chargeTimes) + k * sum(runningCosts) ，其中 max(chargeTimes) 是这 k 个机器人中最大充电时间，sum(runningCosts) 是这 k 个机器人的运行时间之和。

请你返回在 不超过 budget 的前提下，你 最多 可以 连续 运行的机器人数目为多少。

示例 1：

输入：chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25
输出：3
解释：
可以在 budget 以内运行所有单个机器人或者连续运行 2 个机器人。
选择前 3 个机器人，可以得到答案最大值 3 。总开销是 max(3,6,1) + 3 * sum(2,1,3) = 6 + 3 * 6 = 24 ，小于 25 。
可以看出无法在 budget 以内连续运行超过 3 个机器人，所以我们返回 3 。

示例 2：

输入：chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19
输出：0
解释：即使运行任何一个单个机器人，还是会超出 budget，所以我们返回 0 。

提示：

  • chargeTimes.length == runningCosts.length == n
  • 1 <= n <= 5 * 104
  • 1 <= chargeTimes[i], runningCosts[i] <= 105
  • 1 <= budget <= 1015
class Solution {
    /**
        chargeTimes  3 6 1 3 4
        runningCosts 2 1 3 4 5
        与239滑动窗口最大值一样 队首依然是维护chargeTimes的最大元素
        仅仅将固定大小的滑动窗口改为了不固定大小的双指针
     */

    public int maximumRobots(int[] chargeTimes, int[] runningCosts, long budget) {
        int ans = 0;
        Deque<Integer> q = new ArrayDeque<Integer>();
        long sum = 0L;
        for (int left = 0, right = 0; right < chargeTimes.length; right++) {
            //进
            while (!q.isEmpty() && chargeTimes[right] >= chargeTimes[q.peekLast()]) {
                q.pollLast();
            }
            q.addLast(right);
            sum += runningCosts[right];
            //出 
            while (!q.isEmpty() && chargeTimes[q.peekFirst()] + (right - left + 1) * sum > budget) {
                //及时清除无用的数据
                if (q.peekFirst() == left) {
                    q.pollFirst();
                }
                sum -= runningCosts[left++];
            }
            ans = Math.max(ans, right - left + 1);
        }
        return ans;
    }
}

将[子数组]改为[子序列]便是接下来的题目

1383 最大的团队表现值（附加）（堆）

1383. 最大的团队表现值 - 力扣（LeetCode）

给定两个整数 n 和 k，以及两个长度为 n 的整数数组 speed 和 efficiency。现有 n 名工程师，编号从 1 到 n。其中 speed[i] 和 efficiency[i] 分别代表第 i 位工程师的速度和效率。

从这 n 名工程师中最多选择 k 名不同的工程师，使其组成的团队具有最大的团队表现值。

团队表现值 的定义为：一个团队中「所有工程师速度的和」乘以他们「效率值中的最小值」。

请你返回该团队的最大团队表现值，由于答案可能很大，请你返回结果对 10^9 + 7 取余后的结果。

示例 1：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 2
输出：60
解释：
我们选择工程师 2（speed=10 且 efficiency=4）和工程师 5（speed=5 且 efficiency=7）。他们的团队表现值为 performance = (10 + 5) * min(4, 7) = 60 。

示例 2：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 3
输出：68
解释：
此示例与第一个示例相同，除了 k = 3 。我们可以选择工程师 1 ，工程师 2 和工程师 5 得到最大的团队表现值。表现值为 performance = (2 + 10 + 5) * min(5, 4, 7) = 68 。

示例 3：

输入：n = 6, speed = [2,10,3,1,5,8], efficiency = [5,4,3,9,7,2], k = 4
输出：72

提示：

  • 1 <= k <= n <= 10^5
  • speed.length == n
  • efficiency.length == n
  • 1 <= speed[i] <= 10^5
  • 1 <= efficiency[i] <= 10^8
class Solution {
    public int maxPerformance(int n, int[] speed, int[] efficiency, int k) {
       long maxP = 0;
       int[][] engineers = new int[n][2];
       for (int i = 0; i < n; i++) {
           engineers[i][0] = speed[i];
           engineers[i][1] = efficiency[i];
       } 
       //排序
       Arrays.sort(engineers, (a, b) -> b[1] - a[1]);
       PriorityQueue<Integer> pq = new PriorityQueue<>();
       long sumSpeed = 0;
       int minEfficiency = Integer.MAX_VALUE;
       for (int i = 0; i < n; i++) {
           //取出队首元素(即原有工程师中的最低速度)
           if (i >= k) {
               int preS = pq.poll();
               sumSpeed -= preS;
           }
           int[] engineer = engineers[i];
           pq.add(engineer[0]);
           sumSpeed += engineer[0];
           minEfficiency = engineer[1];
           long curP = sumSpeed * minEfficiency;
           maxP = Math.max(maxP, curP);
       }
       return (int) (maxP % (1000000007));
    }
}

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

862. 和至少为 K 的最短子数组 - 力扣（LeetCode）

给你一个整数数组 nums 和一个整数 k ，找出 nums 中和至少为 k 的 最短非空子数组 ，并返回该子数组的长度。如果不存在这样的 子数组 ，返回 -1 。

子数组 是数组中 连续 的一部分。

示例 1：

输入：nums = [1], k = 1
输出：1

示例 2：

输入：nums = [1,2], k = 4
输出：-1

示例 3：

输入：nums = [2,-1,2], k = 3
输出：3

提示：

  • 1 <= nums.length <= 105
  • -105 <= nums[i] <= 105
  • 1 <= k <= 109
class Solution {
    public int shortestSubarray(int[] nums, int k) {
        int n = nums.length;
        long[] pre = new long[n + 1];
        pre[0] = 0;
        for (int i = 0; i < n; i++) {
            pre[i + 1] = pre[i] + nums[i];
        }
        Deque<Integer> q = new ArrayDeque<>();
        int ans = n + 1;
        for (int i = 0; i <= n; i++) {
            long cur = pre[i];
            while (!q.isEmpty() && cur - pre[q.peekFirst()] >= k) {
                ans = Math.min(ans, i - q.pollFirst());
            }
            while (!q.isEmpty() && cur <= pre[q.peekLast()]) {
                q.pollLast();
            }
            q.addLast(i);
        }
        return ans > n ? -1 : ans;
    }
}

1499 满足不等式的最大值

参考题解：1499. 满足不等式的最大值 - 力扣（LeetCode）

给你一个数组 points 和一个整数 k 。数组中每个元素都表示二维平面上的点的坐标，并按照横坐标 x 的值从小到大排序。也就是说 points[i] = [xi, yi] ，并且在 1 <= i < j <= points.length 的前提下， xi < xj 总成立。

请你找出 yi + yj + |xi - xj| 的 最大值，其中 |xi - xj| <= k 且 1 <= i < j <= points.length。

题目测试数据保证至少存在一对能够满足 |xi - xj| <= k 的点。

示例 1：

输入：points = [[1,3],[2,0],[5,10],[6,-10]], k = 1
输出：4
解释：前两个点满足 |xi - xj| <= 1 ，代入方程计算，则得到值 3 + 0 + |1 - 2| = 4 。第三个和第四个点也满足条件，得到值 10 + -10 + |5 - 6| = 1 。
没有其他满足条件的点，所以返回 4 和 1 中最大的那个。

示例 2：

输入：points = [[0,0],[3,0],[9,2]], k = 3
输出：3
解释：只有前两个点满足 |xi - xj| <= 3 ，代入方程后得到值 0 + 0 + |0 - 3| = 3 。

提示：

  • 2 <= points.length <= 10^5
  • points[i].length == 2
  • -10^8 <= points[i][0], points[i][1] <= 10^8
  • 0 <= k <= 2 * 10^8
  • 对于所有的1 <= i < j <= points.length ，points[i][0] < points[j][0] 都成立。也就是说，xi 是严格递增的。
class Solution {
    /** yi+yj+abs(xi-xj)=yi+yj+xj-xi=(yi-xi)+(xj+yj)
        不满足abs(xi-xj)<=k 即xj-xi>k 弹他 
        想要得到xi我们需要用队列来保存
        将(xj,yj-xj)入队 保证队列始终是单调递减
        yj-xj不低于队尾的数据 弹他
     */
    public int findMaxValueOfEquation(int[][] points, int k) {
        int ans = Integer.MIN_VALUE;
        Deque<int[]> q = new ArrayDeque<>();
        for (var p : points) {
            int x = p[0], y = p[1];
            while (!q.isEmpty() && x - q.peekFirst()[0] > k) {
                q.pollFirst();
            }
            if (!q.isEmpty()) {
                ans = Math.max(ans, x + y + q.peekFirst()[1]);
            }
            while (!q.isEmpty() && q.peekLast()[1] <= y - x) {
                q.pollLast();
            }
            q.addLast(new int[]{x, y - x});
        }
        return ans;
    }
}

2944 购买水果需要的最少金币数

参考视频：单调队列优化 DP【力扣双周赛 118】_哔哩哔哩_bilibili

你在一个水果超市里，货架上摆满了玲琅满目的奇珍异果。

给你一个下标从 1 开始的数组 prices ，其中 prices[i] 表示你购买第 i 个水果需要花费的金币数目。

水果超市有如下促销活动：

  • 如果你花费 price[i] 购买了水果 i ，那么接下来的 i 个水果你都可以免费获得。

注意 ，即使你 可以 免费获得水果 j ，你仍然可以花费 prices[j] 个金币去购买它以便能免费获得接下来的 j 个水果。

请你返回获得所有水果所需要的 最少 金币数。

示例 1：

输入：prices = [3,1,2]
输出：4
解释：你可以按如下方法获得所有水果：
- 花 3 个金币购买水果 1 ，然后免费获得水果 2 。
- 花 1 个金币购买水果 2 ，然后免费获得水果 3 。
- 免费获得水果 3 。
注意，虽然你可以免费获得水果 2 ，但你还是花 1 个金币去购买它，因为这样的总花费最少。
购买所有水果需要最少花费 4 个金币。

示例 2：

输入：prices = [1,10,1,1]
输出：2
解释：你可以按如下方法获得所有水果：
- 花 1 个金币购买水果 1 ，然后免费获得水果 2 。
- 免费获得水果 2 。
- 花 1 个金币购买水果 3 ，然后免费获得水果 4 。
- 免费获得水果 4 。
购买所有水果需要最少花费 2 个金币。

提示：

  • 1 <= prices.length <= 1000
  • 1 <= prices[i] <= 105

记忆化搜索

class Solution {
    /** 哪些水果是免费的
        i+1,i+2...2i+1
        下一个购买的水果 j [i+1,2i+1]
        i+1到j-1都是免费获得的
     */

    public int minimumCoins(int[] prices) {
        int n = prices.length;
        int[] cache = new int[(n + 1) / 2];
        return dfs(prices, cache, 1);
    }

    private int dfs(int[] prices, int[] cache, int i) {
        int n = prices.length;
        // if (i > n) {
        //     return 0; // 递归边界
        // }
        if (i * 2 >= n) {
            return prices[i - 1]; // i从1开始 优化递归边界
        }
        if (cache[i] != 0) {
            return cache[i];
        }
        int ans = Integer.MAX_VALUE;
        for (int j = i + 1; j <= 2 * i + 1; j++) {
            ans = Math.min(ans, dfs(prices, cache, j));
        }
        return cache[i] = prices[i - 1] + ans;
    }
}

1:1翻译成递推

class Solution {
    /** 哪些水果是免费的
        i+1,i+2...2i+1
        下一个购买的水果 j [i+1,2i+1]
        i+1到j-1都是免费获得的
     */

    public int minimumCoins(int[] prices) {
        int n = prices.length;
        for (int i = (n + 1) / 2 - 1; i > 0; i--) {
            int mn = Integer.MAX_VALUE;
            for (int j = i; j <= i * 2; j++) {
                mn = Math.min(mn, prices[j]);
            }
            prices[i - 1] += mn;
        }
        return prices[0];
        //int[] f = new int[n + 1];
        // for (int i = n; i > 0; i--) {
        //     if (i * 2 >= n) {
        //         f[i] = prices[i - 1];
        //     } else {
        //         int mn = Integer.MAX_VALUE;
        //         for (int j = i + 1; j <= 2 * i + 1; j++) {
        //             mn = Math.min(mn, f[j]);
        //         }
        //         f[i] = mn + prices[i - 1];
        //     }
        // }
        // return f[1];
    }
}

单调队列优化

class Solution {
    /** 求滑动窗口最小值min(f[i+1:i*2+2])
        左边的小 淘汰掉 右边的大
        保证队尾元素始终最小 即队列单调递减
     */
    public int minimumCoins(int[] prices) {
        int n = prices.length;
        Deque<int[]> q = new ArrayDeque<>();
        q.addLast(new int[]{n + 1, 0});// 哨兵
        for (int i = n; i > 0; i--) {
            while (q.peekLast()[0] > 2 * i + 1) {
                q.pollLast();// 右边离开窗口
            }
            int f = prices[i - 1] + q.peekLast()[1];
            while (f <= q.peekFirst()[1]) {
                q.pollFirst();
            }
            q.addFirst(new int[]{i, f});// 左边进入窗口
        }
        return q.peekFirst()[1];
    }
}

单调栈（灵神笔记）

739 每日温度

739. 每日温度 - 力扣（LeetCode）

给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。

示例 1:

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

示例 2:

输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]

示例 3:

输入: temperatures = [30,60,90]
输出: [1,1,0]

提示：

  • 1 <= temperatures.length <= 105
  • 30 <= temperatures[i] <= 100
class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        int n = temperatures.length;
        int[] ans = new int[n];
        int[] st = new int[n];
        int top = -1;
        for (int i = 0; i < n; i++) {
            int t = temperatures[i];
            //遍历到更大的元素就弹出栈顶元素 
            while (top >= 0 && t > temperatures[st[top]]) {
                int j = st[top--];
                ans[j] = i - j;
            }
            st[++top] = i;
        }
        return ans;
    }
}

42 接雨水

42. 接雨水 - 力扣（LeetCode）

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

img

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9

提示：

  • n == height.length
  • 1 <= n <= 2 * 104
  • 0 <= height[i] <= 105
class Solution {
    public int trap(int[] height) {
        int ans = 0;
        Deque<Integer> st = new ArrayDeque<>();
        for (int i = 0; i < height.length; i++) {
            //遍历到右边的板子 可以接水
            while (!st.isEmpty() && height[i] >= height[st.peek()]) {
                //需要三个下标 栈顶元素(右边板子) 栈顶下面的元素(中间板子) 左边的板子
                //例如 5 2 1 0 4 1 1 6
                //遍历到4 栈从下到上为 5 4 bottomHeight=2
                int bottomHeight = height[st.pop()];
                if (st.isEmpty()) {
                    break;
                }
                //返回队首元素(左板子)
                int left = st.peek();
                //雨水面积的高
                int dh = Math.min(height[left], height[i]) - bottomHeight;
                ans += dh * (i - left - 1);
            }
            st.push(i);
        }
        return ans;
    }
}

1475 商品折扣后的最终价格

1475. 商品折扣后的最终价格 - 力扣（LeetCode）

给你一个数组 prices ，其中 prices[i] 是商店里第 i 件商品的价格。

商店里正在进行促销活动，如果你要买第 i 件商品，那么你可以得到与 prices[j] 相等的折扣，其中 j 是满足 j > i 且 prices[j] <= prices[i] 的 最小下标 ，如果没有满足条件的 j ，你将没有任何折扣。

请你返回一个数组，数组中第 i 个元素是折扣后你购买商品 i 最终需要支付的价格。

示例 1：

输入：prices = [8,4,6,2,3]
输出：[4,2,4,2,3]
解释：
商品 0 的价格为 price[0]=8 ，你将得到 prices[1]=4 的折扣，所以最终价格为 8 - 4 = 4 。
商品 1 的价格为 price[1]=4 ，你将得到 prices[3]=2 的折扣，所以最终价格为 4 - 2 = 2 。
商品 2 的价格为 price[2]=6 ，你将得到 prices[3]=2 的折扣，所以最终价格为 6 - 2 = 4 。
商品 3 和 4 都没有折扣。

示例 2：

输入：prices = [1,2,3,4,5]
输出：[1,2,3,4,5]
解释：在这个例子中，所有商品都没有折扣。

示例 3：

输入：prices = [10,1,1,6]
输出：[9,0,1,6]

提示：

  • 1 <= prices.length <= 500
  • 1 <= prices[i] <= 10^3
class Solution {
    public int[] finalPrices(int[] prices) {
        /** 题目让我们找到i右边最近的满足prices[j]<=prices[i]的元素
            相当于 找到j左边最近的比起本身更大的元素
         */
        Deque<Integer> st = new ArrayDeque<>();
        int n = prices.length;
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            //遍历到的prices[i]<=栈顶元素 弹他
            while (!st.isEmpty() && prices[i] <= prices[st.peekLast()]) {
                int temp = st.peekLast();
                st.removeLast();
                ans[temp] = prices[temp] - prices[i];
            }
            st.add(i);
            ans[i] = prices[i];
        }
        return ans;
    }
}

901 股票价格跨度

901. 股票价格跨度 - 力扣（LeetCode）

设计一个算法收集某些股票的每日报价，并返回该股票当日价格的 跨度 。

当日股票价格的 跨度 被定义为股票价格小于或等于今天价格的最大连续日数（从今天开始往回数，包括今天）。

  • 例如，如果未来 7 天股票的价格是 [100,80,60,70,60,75,85]，那么股票跨度将是 [1,1,1,2,1,4,6] 。

实现 StockSpanner 类：

  • StockSpanner() 初始化类对象。
  • int next(int price) 给出今天的股价 price ，返回该股票当日价格的 跨度 。

示例：

输入：
["StockSpanner", "next", "next", "next", "next", "next", "next", "next"]
[[], [100], [80], [60], [70], [60], [75], [85]]
输出：
[null, 1, 1, 1, 2, 1, 4, 6]

解释：
StockSpanner stockSpanner = new StockSpanner();
stockSpanner.next(100); // 返回 1
stockSpanner.next(80);  // 返回 1
stockSpanner.next(60);  // 返回 1
stockSpanner.next(70);  // 返回 2
stockSpanner.next(60);  // 返回 1
stockSpanner.next(75);  // 返回 4 ，因为截至今天的最后 4 个股价 (包括今天的股价 75) 都小于或等于今天的股价。
stockSpanner.next(85);  // 返回 6

提示：

  • 1 <= price <= 105
  • 最多调用 next 方法 104 次
class StockSpanner {
    private final Deque<int[]> stack = new ArrayDeque<>();
    private int curDay = -1;

    public StockSpanner() {
        //无需判断栈为空
        stack.push(new int[]{-1, Integer.MAX_VALUE});
    }
    
    public int next(int price) {
        while (price >= stack.peek()[1]) {
            stack.pop();
        }
        int ans = ++curDay - stack.peek()[0];
        stack.push(new int[]{curDay, price});
        return ans;
    }
}

/**
 * Your StockSpanner object will be instantiated and called as such:
 * StockSpanner obj = new StockSpanner();
 * int param_1 = obj.next(price);
 */

1019 链表中的下一个更大节点

1019. 链表中的下一个更大节点 - 力扣（LeetCode）

给定一个长度为 n 的链表 head

对于列表中的每个节点，查找下一个 更大节点 的值。也就是说，对于每个节点，找到它旁边的第一个节点的值，这个节点的值 严格大于 它的值。

返回一个整数数组 answer ，其中 answer[i] 是第 i 个节点( 从1开始 )的下一个更大的节点的值。如果第 i 个节点没有下一个更大的节点，设置 answer[i] = 0 。

示例 1：

img

输入：head = [2,1,5]
输出：[5,5,0]

示例 2：

img

输入：head = [2,7,4,3,5]
输出：[7,0,5,5,0]

提示：

  • 链表中节点数为 n
  • 1 <= n <= 104
  • 1 <= Node.val <= 109
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public int[] nextLargerNodes(ListNode head) {
        int n = 0;
        for (ListNode cur = head; cur != null; cur = cur.next) {
            n++;
        }
        int[] ans = new int[n];
        Deque<Integer> st = new ArrayDeque<>();// 保存节点下标
        int i = 0;
        for (ListNode cur = head; cur != null; cur = cur.next) {
            while (!st.isEmpty() && ans[st.peek()] < cur.val) {
                ans[st.pop()] = cur.val;// 更新答案
            }
            st.push(i);
            ans[i++] = cur.val;
        }
        for (var index : st) {
            ans[index] = 0;
        }
        return ans;
    }
}

84 柱状图中最大的矩形

84. 柱状图中最大的矩形 - 力扣（LeetCode）

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

示例 1:

img

输入：heights = [2,1,5,6,2,3]
输出：10
解释：最大的矩形为图中红色区域，面积为 10

示例 2：

img

输入： heights = [2,4]
输出： 4

提示：

  • 1 <= heights.length <=105
  • 0 <= heights[i] <= 104
class Solution {
    public int largestRectangleArea(int[] heights) {
        int ans = 0;
        Deque<Integer> st = new ArrayDeque<>();
        int n = heights.length;
        //l[i]为左边最近的比其小的下标 r[i]为右边最近的比其小的下标
        int[] l = new int[n], r = new int[n];
        Arrays.fill(l, -1);// 初始化-1
        Arrays.fill(r, n);// 初始化n
        for (int i = 0; i < n; i++) {
            while (!st.isEmpty() && heights[i] < heights[st.peekLast()]) {
                r[st.pollLast()] = i;
            }
            st.addLast(i);
        }
        st.clear();
        for (int i = n - 1; i >= 0; i--) {
            while (!st.isEmpty() && heights[i] < heights[st.peekLast()]) {
                l[st.pollLast()] = i;
            }
            st.addLast(i);
        }
        for (int i = 0; i < n; i++) {
            int h = heights[i];
            ans = Math.max(ans, (r[i] - l[i] - 1) * h);
        }
        return ans;
    }
}
我是鼠鼠大王666
关注
  • 15
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构与算法拓展】 单调队列原理及代码实现
wayne_lee_lwc的博客
10-28 963
前言 数据结构，一门数据处理的艺术，精巧的结构在一个又一个算法下发挥着他们无与伦比的高效和精密之美，在为信息技术打下坚实地基的同时，也令无数开发者和探索者为之着迷。 也因如此，它作为博主大二上学期最重要的必修课出现了。由于大家对于上学期C++系列博文的支持，我打算将这门课的笔记也写作系列博文，既用于整理、消化，也用于同各位交流、展示数据结构的美。 此系列文章，将会分成两条主线，一条“数据结构基础”，一条“数据结构拓展”。“数据结构基础”主要以记录课上内容为主，“拓展”则是以课上内容为基础的更加高深的数据结构
数据结构-单调队列
weixin_45532984的博客
01-11 737
与单调栈相似，单调队列里存的也是具有单调性质的数据。单调队列与普通队列不一样的地方就在于单调队列既可以从队首出队，也可以从队尾出队。即是两个方向都可以进出的“单调栈”。
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何具体存储。例如，数组的连续存储，链表的动态分配节点，树和图的邻接矩阵或邻接表表示等。 基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，使得计算机可以执行以求解问题。 算法特性：包括输入、输出、有穷性、确定性和可行性。即一个有效的算法必须能在有限步骤内结束，并且对于给定的输入产生唯一的确定输出。 算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界法等。 算法分析：通过数学方法分析算法的时间复杂度（运行时间随数据规模增长的速度）和空间复杂度（所需内存大小）来评估其效率。 学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等。
单调队列与优先级队列详述
最新发布
weixin_61500998的博客
03-10 914
优先级队列（Priority Queue）：是一种特殊的队列数据结构，其中的元素具有优先级。在优先级队列中，元素按照优先级的顺序进行排序，每次从队列中取出的元素都是具有最高优先级的元素。它在处理最值方面的问题优势较大。总结来说，单调队列和优先队列是两种不同的数据结构，适用于不同的场景和问题。：优先队列通常使用堆（二叉堆或斐波那契堆）来实现，这使得插入和删除操作的时间复杂度为O(log n)，其中n是队列中元素的数量。通常，单调队列维护一个递增或递减的顺序，以便在常数时间内获取队列中的最大或最小元素。
数据结构与算法-学习笔记 Java 版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何具体存储。例如，数组的连续存储，链表的动态分配节点，树和图的邻接矩阵或邻接表表示等。 基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，使得计算机可以执行以求解问题。 算法特性：包括输入、输出、有穷性、确定性和可行性。即一个有效的算法必须能在有限步骤内结束，并且对于给定的输入产生唯一的确定输出。 算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法，分支限界法等。 算法分析：通过数学方法分析算法的时间复杂度（运行时间随数据规模增长的速度）和空间复杂度（所需内存大小）来评估其效率。 学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构与算法--栈与队列
LeiGerのBlog
02-24 208
栈与队列1、设计一个能获取当前栈的最小值的栈 1、设计一个能获取当前栈的最小值的栈 设计一个能获取当前栈的最小值的栈。 大致思路： 1、申请两个栈，一个普通栈stackData，一个能获取最小值的栈stackMin； 2、给两个栈中同时压入数据，压数规则：同时给两个栈压入数据，当要压入的数比stackMin栈顶的元素小时，将该数同时压入两栈，如果要压入的数大于stackMin栈顶的元素小时，将该数压入stackData中，将stackMin栈顶的数重新再压入stackMin，具体细节详见代码注释。 举例
单调队列(java)
weixin_43805402的博客
02-21 2310
单调队列，顾名思义，就是队列中的值要么单调递增要么单调递减。之前做题的时候对这个并没有太在意，但是今天的每日抑题用堆实现的时候发现太耗时了，借此机会好好学一下单调队列。 leetcode1438 求满足条件的最长连续子数组的长度，一看就是滑动窗口的题，按着模板来就行，但是这里难的点在于要维护窗口内的最大值和最小值，只要保证在扩张右边界和收缩左边界的时候可以拿到窗口内的最大值和最小值，这个题就迎刃而解了。所以第一想法是用两个堆来分别维护最大值和最小值，代码如下： public int longestSubar
单调队列--滑动窗口（双端队列）
weixin_63001635的博客
01-25 486
求窗口极值（一般：队头/队尾就是该窗口的极小/极大值）找出最近的数O(kn)：使用队列装最小值的位置index，每次装入一个元素，判断这个新元素是否比队列当前元素要小。遍历：首先，如果队列中有数（位置），但该数对应的值已经离开了窗口（，i是当前位置），弹出队头。（滑动一次判断一次）while：队列中有数，但是队尾元素大于这个新进窗口的元素,弹出队尾元素，直到队尾元素小于当前值 或者 队列已经没有元素。此时队头元素就是该窗口的最小值。再将该值装入队列。最后会形成一个单调上升的队列序列。
单调队列（例题详解+模板cpp）
ylh的博客
03-28 814
蓝桥杯算法复习：单调队列基本知识与例题讲解+模板c++
单调队列/栈与双向队列集合
10-02
本人自己做的类，虽说只是测试版，但已经可以胜任一部分任务了 PS：双向队列是基础类，单调队列、单调栈是结果类
第5章 单调队列优化动态规划（2021.08.23）.pdf
08-23
第5章 单调队列优化动态规划（2021.08.23）.pdf
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
包含线性表，栈，队列，串等结构的代码示例，及一些栈和队列的应用。
数据结构学习笔记 5-1 单调队列（Monotone-Queue）与 LeetCode真题（Java）
How many ten years in the life time?
09-02 402
单调队列就是一种特殊的结构，解决窗口在滑动过程中的最值问题。维护一个单调队列 存放窗口的最小值// n为元素个数 k为滑动窗口大小 for(int i = 0;i < n;// 双端队列 // 最小值 for(int i = 0;i < n;i ++) {// 如果队尾元素大于当前元素 则将队尾元素删除 放入当前元素 (保证单调性) while(!// 放入队尾 if(i - q . peekFirst() == k) q . removeFirst();...
数据结构与算法---单调栈结构
figting
10-16 109
1 滑动窗口问题。
单调队列java_深入浅出搞通单调队列单调栈
weixin_30205357的博客
02-13 223
下面我们通过几个题目由浅入深，一点一点挖透他们吧！提纲单调队列剑指 Offer 59 - II. 队列的最大值题目描述：请定义一个队列并实现函数 max_value 得到队列里的最大值若队列为空，pop_front 和 max_value 需要返回 -1示例 1：输入: ["MaxQueue","push_back","push_back","max_value","pop_front","max...
单调队列java_单调队列怎么用java实现
weixin_33374400的博客
02-13 478
展开全部可以用java1.7的优先队列，实现相应对象的比32313133353236313431303231363533e78988e69d8331333337373665较器classPoint{intx,y;publicPoint(intx,inty){this.x=x;this.y=y;}publicStringtoString(){return"("+...
洛谷 P1886 滑动窗口 /【模板】单调队列 Java实现
m0_52238102的博客
06-08 455
有一个长为 nnn 的序列 aaa，以及一个大小为 kkk 的窗口。现在这个从左边开始向右滑动，每次滑动一个单位，求出每次滑动后窗口中的最大值和最小值。例如：The array is [1,3,−1,−3,5,3,6,7][1,3,-1,-3,5,3,6,7][1,3,−1,−3,5,3,6,7], and k=3k = 3k=3。输入一共有两行，第一行有两个正整数 n,kn,kn,k。 第二行 nnn 个整数，表示序列 aaa输出共两行，第一行为每次窗口滑动的最小值 第二行为每次窗口滑动的最大值 样例输出
数据结构与算法 - 队列
09-12
队列（Queue）是一种先进先出（FIFO）的数据结构，类似于现实生活中排队的概念。它有两个基本操作：入队（enqueue）和出队（dequeue）。 入队操作将元素添加到队列的末尾，出队操作则从队列的头部移除元素并返回它...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值