数据结构 | 单调栈入门及例题

最新推荐文章于 2022-06-28 21:23:04 发布
最新推荐文章于 2022-06-28 21:23:04 发布
阅读量206 收藏 1
点赞数
分类专栏： # 笔记 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Encore47/article/details/110134863
版权

入门理解

有图解

单调栈原理及应用 详解 附各种类型的题目练习

模拟了一下，理解左右扩展的意思

应用

POJ 3250

求某元素向右最远的比它小的元素位置

解题思路

单调递增栈（从栈顶到栈底单调递增）。

注意事项

n s [ n ] ns[n] ns[n] 设置一个最大的数，用于最后弹出所有数。

#include<iostream>
#include<cstring>
#include<cmath>
#include<stack>

using namespace std;
//#define LOCAL  //提交的时候一定注释
#define _for(i, a, b) for(int i = (a); i < (b); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define pb push_back
#define VI vector<int>
#define mp make_pair
#define lowbit(x) ((x) & (-x))
#define ls rt << 1
#define rs rt << 1
#define M ((l + r) >> 1)
const int INT_M = 0x3f3f3f3f;
typedef long long LL;
typedef double db;
const db eps = 1e-8;  //定义浮点数误差
const int MOD = 998244353;
const int maxn = 1e5 + 10;
const LL INF = 1e18;

int readint() {
    int k;
    scanf("%d", &k);
    return k;
}
int ns[maxn], r[maxn];

int main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    int n;
    LL sum = 0;
    scanf("%d", &n);
    _for(i, 0, n) ns[i] = readint();
    ns[n] = INT_M;  //设置一个最大的数，用于最后弹出所有数
    stack<int> st;  //构造单调递增栈
    _rep(i, 0, n) {
        while (!st.empty() && ns[i] >= ns[st.top()]) {
            r[st.top()] = i;
            sum += i - st.top() - 1;
            st.pop();
        }
        st.push(i);
    }

    printf("%lld", sum);

    return 0;
}

求子序列中的最小值乘子序列的长度最大

POJ - 2559

解题思路

单调递减栈同时求出 n s [ i ] ns[i] ns[i] 右边第一个比它小的元素位置 r r r ，以及左边第一个比它小的元素位置 l l l 。

上面两个位置选择一个进行 + 1 +1 +1 或 − 1 -1 −1 操作，方便求解面积。

本题选择维护直接存 r r r 的数组 r [ i ] r[i] r[i]（相当于最后左右要求两边大于 n s [ i ] ns[i] ns[i] 的最远端点相减后 + 1 +1 +1 ），以及将 l + 1 l + 1 l+1 得到的数组 l [ i ] l[i] l[i]，其含义为：左边大于 n s [ i ] ns[i] ns[i] 的数能延伸的最远位置~

参考代码

#include<iostream>
#include<cstring>
#include<cmath>
#include<stack>
using namespace std;
#define LOCAL  //提交的时候一定注释
#define _for(i, a, b) for(int i = (a); i < (b); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define pb push_back
#define VI vector<int>
#define mp make_pair
#define lowbit(x) ((x) & (-x))
#define ls rt << 1
#define rs rt << 1
#define M ((l + r) >> 1)
const int INT_M = 0x3f3f3f3f;
typedef long long LL;
typedef double db;
const db eps = 1e-8;  //定义浮点数误差
const int MOD = 998244353;
const int maxn = 1e5 + 10;
const LL INF = 1e18;

int readint() {
    int k;
    scanf("%d", &k);
    return k;
}
int ns[maxn], r[maxn], l[maxn];

int main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    int n;
    while (~scanf("%d", &n) && n) {
        LL ans = -1;
        memset(r, 0, sizeof(r));
        memset(l, 0, sizeof(l));
        _for(i, 0, n) ns[i] = readint();
        ns[n] = -1;  //设置一个最小的数，用于最后弹出所有数
        stack<int> st;  //构造单调递减栈
        _rep(i, 0, n) {
            while (!st.empty() && ns[i] < ns[st.top()]) {
                r[st.top()] = i;
                st.pop();
            }
            l[i] = st.size() == 0 ? 0 : st.top() + 1;
            st.push(i);
        }
        _for(i, 0, n) {
            if (r[i] == 0) r[i] = n;
            ans = max(ans, 1LL * (r[i] - l[i]) * ns[i]);
        }
        printf("%lld\n", ans);

    }
    return 0;
}

上面一题的拓展：POJ 3494

解题思路

先进行预处理，每一行的某个元素赋值为紧邻的连续 1 1 1 的个数，再对每一行做上面的单调递减栈操作即可。

注意事项

1.用stack会超时，用数组模拟过了。

int st[maxn];

int t = 0;
_rep(i, 0, m) {
    while (t && a[i] < a[st[t - 1]]) {
        r[st[t - 1]] = i;
        t--;
    }
    l[i] = t == 0 ? 0 : st[t - 1] + 1;
    st[t++] = i;
}

后来发现是因为处理每一行都开了一个 stack …

不要重复开很多个，写在里面循环会TLE。

代码（TLE）

#include<iostream>
#include<cstring>
#include<cmath>
#include<stack>
using namespace std;
#define LOCAL  //提交的时候一定注释
#define _for(i, a, b) for(int i = (a); i < (b); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define pb push_back
#define VI vector<int>
#define mp make_pair
#define lowbit(x) ((x) & (-x))
#define ls rt << 1
#define rs rt << 1
#define M ((l + r) >> 1)
const int INT_M = 0x3f3f3f3f;
typedef long long LL;
typedef double db;
const db eps = 1e-8;  //定义浮点数误差
const int maxn = 2010;
const LL INF = 1e18;

int readint() {
    int k; scanf("%d", &k); return k;
}

int ns[maxn], r[maxn], l[maxn];

int main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        LL ans = 0;
        memset(ns, 0, sizeof(ns));
        ns[m] = -1;  //保证最后能把所有元素弹出
        _for(j, 0, n) {
            _for(i, 0, m) ns[i] = readint() ? ns[i] + 1 : 0;
            memset(r, 0, sizeof(r));
            memset(l, 0, sizeof(l));
            stack<int> st;  //构造单调递减栈
            _rep(i, 0, m) {
                while (!st.empty() && ns[i] <= ns[st.top()]) {  //这里用<=，否则TLE？
                    r[st.top()] = i;
                    st.pop();
                }
                l[i] = st.empty() ? 0 : st.top() + 1;
                st.push(i);
            }
            _for(i, 0, m) {
                ans = max(ans, 1LL * (r[i] - l[i]) * ns[i]);
            }
        }
        printf("%lld\n", ans);
    }
    return 0;
}

参考代码（使用stack）

#include<iostream>
#include<cstring>
#include<cmath>
#include<stack>
using namespace std;
#define LOCAL  //提交的时候一定注释
#define _for(i, a, b) for(int i = (a); i < (b); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define pb push_back
#define VI vector<int>
#define mp make_pair
#define lowbit(x) ((x) & (-x))
#define ls rt << 1
#define rs rt << 1
#define M ((l + r) >> 1)
const int INT_M = 0x3f3f3f3f;
typedef long long LL;
typedef double db;
const db eps = 1e-8;  //定义浮点数误差
const int MOD = 998244353;
const int maxn = 2010;
const LL INF = 1e18;

int readint() {
    int k;
    scanf("%d", &k);
    return k;
}
int ns[maxn], a[maxn], r[maxn], l[maxn];

int main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    int n, m;
    stack<int> st;  //构造单调递减栈，注意不要重复开很多个，写在里面循环会TLE
    while (~scanf("%d%d", &n, &m)) {
        LL ans = 0;
        memset(ns, 0, sizeof(ns));
        a[m] = -1;
        _for(j, 0, n) {
            while (!st.empty()) st.pop();
            _for(i, 0, m) {
                int k = readint();
                if (k) ns[i] = ns[i] + 1;
                else ns[i] = 0;
                a[i] = ns[i];
            }
            memset(r, 0, sizeof(r));
            memset(l, 0, sizeof(l));
            _rep(i, 0, m) {
                while (!st.empty() && a[i] < a[st.top()]) {
                    r[st.top()] = i;
                    st.pop();
                }
                l[i] = st.empty() ? 0 : st.top() + 1;
                st.push(i);
            }
            _for(i, 0, m) {
                if (r[i] == 0) r[i] = m;
                ans = max(ans, 1LL * (r[i] - l[i]) * ns[i]);
            }
        }
        printf("%lld\n", ans);

    }
    return 0;
}

求每种长度子序列中的最大值的最小值

数据分析

解题思路

对数 a s [ i ] as[i] as[i]，求其是某个子序列的最大值的这个子序列长度。

即要求向右、向左走比 a s [ i ] as[i] as[i] 小的数延伸的最远距离，那么就采取类似上面的思想，求 r [ i ] r[i] r[i] 和 l [ i ] l[i] l[i] （只不过这里是单调递增栈），然后去维护每个子序列长度对应的最大值，每次都取最小值。

注意事项

1.最后记得对结果处理一下，可能有的长度没有值，那么就继承比其长的长度的值。

参考代码

#define _for(i, a, b) for(int i = (a); i < (b); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
const int maxn = 1e5 + 10;
const int INT_M = 0x3f3f3f3f;
int r[maxn], l[maxn], ans[maxn];
class Solution {
public:
    /**
     * 找到所有长度子数组中最大值的最小值
     * @param numbers int整型vector 牛牛给出的数据
     * @return int整型vector
     */

    vector<int> getMinimums(vector<int>& as) {
        // write code here
        vector<int> ans_vec;
        int n = as.size();
        memset(r, 0, sizeof(r));
        memset(l, 0, sizeof(l));
        as.push_back(INT_M);  //设置一个最大的数，用于最后弹出所有数
        stack<int> st;  //构造单调递减栈
        _rep(i, 0, n) {
            while (!st.empty() && as[i] >= as[st.top()]) {
                r[st.top()] = i;
                st.pop();
            }
            l[i] = st.size() == 0 ? 0 : st.top() + 1;
            st.push(i);
        }
        int len;
        fill(ans, ans + maxn, INT_M);
        _for(i, 0, n) {
            len = r[i] - l[i];
            ans[len] = min(ans[len], as[i]);
        }
        for(int i = n; i >= 2; --i) {
            ans[i - 1] = min(ans[i - 1], ans[i]);
        }
        _rep(i, 1, n) ans_vec.push_back(ans[i]);
        return ans_vec;
    }
};

子序列中的最小值乘以子序列所有元素和最大

POJ 2796

注意事项

1.数组开 l o n g   l o n g long\ long long long！！！！！

2.前缀和的维护，如计算从 i i i 到 j j j 的和，即计算 p r e [ j ] − p r e [ i − 1 ] pre[j] - pre[i - 1] pre[j]−pre[i−1]。 p r e [ 0 ] = 0 pre[0] = 0 pre[0]=0 方便处理。

3.本代码中相当于 j = r [ m ] + 1 − 1 j = r[m] + 1 - 1 j=r[m]+1−1， i = l [ m ] + 1 − 1 i = l[m] + 1 - 1 i=l[m]+1−1。

参考代码

#include<iostream>
#include<cstring>
#include<cmath>
#include<stack>
using namespace std;
#define LOCAL  //提交的时候一定注释
#define _for(i, a, b) for(int i = (a); i < (b); ++i)
#define _rep(i, a, b) for(int i = (a); i <= (b); ++i)
#define pb push_back
#define VI vector<int>
#define mp make_pair
#define lowbit(x) ((x) & (-x))
#define ls rt << 1
#define rs rt << 1
#define M ((l + r) >> 1)
const int INT_M = 0x3f3f3f3f;
typedef long long LL;
typedef double db;
const db eps = 1e-8;  //定义浮点数误差
const int maxn = 1e5 + 10;
const LL INF = 1e18;

int readint() {
    int k; scanf("%d", &k); return k;
}

int ns[maxn], r[maxn], l[maxn];
LL pre[maxn];  //前缀和数组

int main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    int m;
    scanf("%d", &m);
    LL ans = -1;
    memset(ns, 0, sizeof(ns));
    memset(pre, 0, sizeof(pre));
    ns[m] = -1;  //保证最后能把所有元素弹出
    pre[0] = 0;
    _for(i, 0, m) {
        ns[i] = readint();
        pre[i + 1] = pre[i] + ns[i];
    }
    memset(r, 0, sizeof(r));
    memset(l, 0, sizeof(l));
    stack<int> st;  //构造单调递减栈
    _rep(i, 0, m) {
        while (!st.empty() && ns[i] < ns[st.top()]) {  //这里用<=，否则TLE？
            r[st.top()] = i;
            st.pop();
        }
        l[i] = st.empty() ? 0 : st.top() + 1;
        st.push(i);
    }
    int ln = 1, rn = 1;
    LL tmp;
    _for(i, 0, m) {
        r[i] = r[i] ? r[i] : m;
        tmp = 1LL * (pre[r[i]] - pre[l[i]]) * ns[i];  //这里注意下标的处理
        if (tmp > ans) {ans = tmp; ln = l[i] + 1; rn = r[i];}
    }
    printf("%lld\n", ans);
    if (!ans) ln = rn = 1;
    printf("%d %d", ln, rn);
    return 0;
}
️kcuL ytnelP
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
华为4-22笔试——子序列最小和的最大值排列
04-22 966
一个序列 m个数，分成k个子序列，S[i]表示第i个子序列的和。要使S[i]的最小值尽可能大；S[i]的最小值相同时，按照S[0]最小、S[1]最小排列，输出第一个 样例1 输入：6 3 1 2 3 2 5 4 输出：1 2 3 / 2 5 / 4 样例2 输入：9 3 100 200 300 400 500 600 700 800 900 输出：100 200 300 400 500 / 600...
数据结构例题及参考答案
02-15
本资料集“数据结构例题及参考答案”旨在帮助学习者深入理解并掌握各种数据结构及其应用。下面将详细阐述数据结构的主要类型、重要概念以及相关例题解题策略。 一、线性数据结构 1. 数组：数组是最基本的数据结构，...
给定正数数组arr，求任意子数组最小值与子数组累加和的乘积最大值是多少
weixin_46838716的博客
05-14 381
1）单调栈的敏感度：求滑动窗口内的最大值，最小值，或者，求i左边右边距离i最近比i小的位置L,R 2）前缀累加和数组pre的敏感度，要随时可以想到，尤其是arr大于0时，这个可以加速算法。 3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。
求子序列和/乘积 最值
H.T.Yuan的博客
03-21 289
最近在学习《数据结构与算法分析》C语言时，第二章内容中出现了几个比较新颖的算法，这里记录一下。 1. a.求最小子序列和： //思路是，逐步计算，如果ThisSum 是正数， //则ThisSum对于后面的数而言是累赘，舍去 int MinSubsequenceSum(vector<int>& V) { int length = V.size(); int MinSum = V[0]; int ThisSum = 0; for(int i = 0; i &
[ACM] POJ 2796 Feel Good （求序列中子序列的和与子序列中的最小数最大乘积）
逆风的方向 更适合飞翔
07-21 2832
Feel Good Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 9186   Accepted: 2509 Case Time Limit: 1000MS   Special Judge Description Bill is developi
POJ 2796 Feel Good (单调栈，前缀和)
qq_38232157的博客
02-05 106
题目意思： 给你一个序列，让你求其中一个子序列使得这个子序列和乘以这个子序列中最小值后最大。 做法： 1、 单调栈的典型题，可以吧每个 emotion[i] 看做是一个矩形，宽度为1，高度为 emotion[i] 2、 题目转化为，以某点为中心(假设这点emotion 是最小的)，往左和往右延伸，只要大于该中心的，就加入。 题目要求，所有的矩形的面积总和 * 该点的高度emotion[i] 。 假...
C语言数据结构学习笔记及例题
10-29
数据结构学习笔记及例题
数据结构 栈的操作实例详解
08-30
数据结构 栈的操作实例详解 数据结构中的栈是一种基本的数据结构，它的操作包括初始化、入栈、出栈、空栈判断等。下面我们将详细介绍栈的操作实例。 栈的定义 栈是指按照后进先出的原则来存储和取出元素的数据...
数据结构与算法概念和例题详解
最新发布
03-30
本资料集《数据结构与算法概念和例题详解》专注于这两个核心概念，特别针对蓝桥杯竞赛进行了讲解，旨在帮助学习者掌握其精髓，并提升实际应用能力。 首先，我们来探讨数据结构。数据结构是组织和存储数据的方式，它...
数据结构1800例题与答案之集合.doc
12-13
"数据结构1800例题与答案之集合" 本资源摘要信息收集了数据结构领域中1800例题与答案的集合，涵盖了数据结构的多个方面，包括顺序查找、二分查找、折半查找、线性表、二叉查找树等。下面是对每个问题的详细解释： ...
数据结构基础复习题
03-20
数据结构 .AOE网是有向带权图，可用来估算工程的完成时间。已知某项工程对应的AOE网G有6个顶点（顶点编号为0～5），其邻接矩阵A为上三角矩阵（对角线全为零时，不存储其对应的权值），按行优先保存在如下的一维数组中。要求： 写出G的邻接矩阵。 （1）画出此工程对应的有向带权图G。 （2）写出以顶点V0出发深度、广度遍历图G（以邻接矩阵存储）所得的两种顶点序列。 （3）求图G的关键路径，并计算该关键路径的长度（即预计完成此项工程的工期）。
数据结构基础练习题(有答案)
08-18
数据结构基础练习题(有答案)
LeetCode（数据结构入门题单——数组部分）
pied_piperG的博客
06-28 664
前一段时间连续地坚持了好像是7天的每日题单，然后就赶上考试周了...一切搁浅，只能是勉强支撑着不掉队，最后磕磕绊绊倒也差不多刷完了，但不乏有水的题和看了答案没复习会忘的，因此想分写两篇文章总结一下。以后的leetcode还是要及时总结。数组：1~5天数组都用vector表示之后方便了很多，可以直接复制数组，在函数调用时也少了很多麻烦（听舍友广州王说好像可以免去一些指针问题）。二维数组用vectorexample(r,vector(c))表示但是再高维的数组怎么表示呢。还......
左神算法笔记（十六）——单调栈结构
02-07 622
单调栈解决的问题 单调栈解决的问题是在一个数组中想知道所有数中，左边离他近的比他大的和右边离他近的比他大的数 思考的问题：如果知道所有数上得到上述要求，同时复杂度满足O(N)。 单调栈结构：单调栈内，从栈底到栈顶满足从大到小。 例如：5（0）4（1）3（2）6（3）后面括号代表所属位置 入栈的过程： 5（0）压入栈然后4（1）比5（0）小，所以将4（1）压入栈中 第三步因为3（2）比4（1）小，...
数据结构与算法之栈入门题目
努力努力再努力L
06-26 653
数据结构与算法之栈题目 目录 用数组实现大小固定的队列和栈 实现一个特殊的栈，在实现栈的基础功能上，再实现返回栈中最小元素的操作 如果仅用栈结构实现队列结构 如何仅用队列结构实现栈结构 1. 用数组实现大小固定的栈和队列 （一）数组实现大小固定的栈思路 创建一个变量size指向数组0位置上 当执行push操作时将添加的num加到size指的位置上，然后size++ 当执行...
单调栈学习+例题：小c的数学问题
ZangWhe
04-08 1207
单调栈： 字面意思就是一个结构栈其中的元素是单调的（严格递增或递减） 对于一个新元素的加入，会把栈顶所有破坏单调性的元素给“弹走”，例如：【7，5，3，新加入一个元素5，会把原栈中的5，3“弹走”，这时形成新的栈为【7，5 用途： 最基础的应用就是给定一组数，针对每个数，寻找它和它右边第一个比它大的数之间有多少个数。 给定一序列，寻找某...
单调栈 四个例题
MaxVen
11-08 160
普通栈就5个操作 #include<stack> 0.stack<类型> 名字; 创建 1.名字.push(元素); 压入栈变为新的栈顶 2.m=名字.top(); 获取栈顶元素 3.名字.pop() ; 弹出栈顶元素 4.length=名字.size() 获取栈内元素长度 ps: 对于 顺序栈和链栈 相对于普通栈来说 效率会相对高...
左神算法：单调栈结构（Java版）
热门推荐
寒泉
12-04 6万+
本题来自左神《程序员面试代码指南》“单调栈结构”题目。 题目 给定一个不含有重复值的数组 arr，找到每一个 i 位置左边和右边离 i 位置最近且值比 arr[i] 小的位置。返回所有位置相应的信息。 举例 输入： arr = {3, 4, 1, 5, 6, 2, 7} 返回如下二维数组作为结果： { {-1, 2}, // -1表示不存在，整体含义为：arr[0]左边离arr[0]最近且比arr[0]小的是arr[-1]， // arr[0]右边离arr[0]最近且.
模运算公式整理
Encore47的博客
02-09 7107
整理ACM中常用的模运算公式，包括加减乘除、幂运算。
数据结构程序设计实战：例题与解答
此书适合计算机科学及相关专业的本科与专科学生作为学习数据结构的辅助教材，同时也适用于考研和计算机等级考试的备考者。" 本书详细讲解了数据结构中的重要概念，首先在第1章介绍了数据结构的概述，涵盖了数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值