[算法]（单调队列、单调栈）和相关例题_算法单调栈原理实际例题-CSDN博客

一、单调队列

单调队列：一种严格满足队内元素单调递增或递减的数据结构。单调队列与普通队列不同的是单调队列可以从队首出队，也可以从队尾出队。

1.1 滑动窗口

模板题：原题链接
下图是根据这题来演示一下取最大值，保证队列内递减，然后输出队首这个最大数：
在这里插入图片描述

在这里插入图片描述

下面是取大数的例子，如果是取小数的que[tail] <= a[i]改为que[tail] >= a[i]。

///que[]
///a[]待处理的元素
///p[]记录存进队列的元素的下标
void humdrum_maxque(){
  head = 1;
  tail = 0;
  for(int i = 1;i <= n; i++){///取最大
    while(head < = tail && que[tail] <= a[i]) tail--;///比较当前队列里的元素与待处理的元素
    que[++tail] = a[i];
    p[tail] = i;
    while(p[head] <= i-k) head++;///p的元素个数是限制在k范围内，因为每一个k内都要输出一个最大数
    if(i >= k) printf("%d ",que[head]);///保证起始从下标k开始输出
  }
}

1.2 最大子序和

模板题：原题链接
在这里插入图片描述

#include<stdio.h>
#define max(a,b) a>b?a:b
const int maxn=3e5+10;
const int INF = 0x3f3f3f3f;
int que[maxn];
int arr[maxn];
int sum[maxn];
int n,k;
int main()
{
	scanf("%d%d",&n,&k);
	sum[0] = 0;
	que[1] = 0;
	for(int i = 1;i <= n; i++){
        scanf("%d",&arr[i]);
        sum[i] = sum[i-1] +arr[i];///
	}
	int l,r,ans;
	l=r=1;
	ans = -INF;
	for(int i = 1;i <= n;i++){
        while(l<=r&&que[l]<i-k) l++;///判断是否滑出窗口
        ans = max(ans,sum[i]-sum[que[l]]);
        while(l <= r&&sum[que[r]] >= sum[i]) r--;
            que[++r] = i;///把小数存下来
	}
	printf("%d\n",ans);
	return 0;
}

二、单调栈

单调栈：分为单调递增栈和单调递减栈，也就是栈内元素保持递增、递减。
单调栈基础应用：

1.给定一组数，跑出每个数和他右边第一个比他大(小)的数之间有多少个数。

2.给定一序列，寻找某一子序列使得子序列中的最小值乘以子序列的长度最长。

3.给定一序列，寻找某一子序列使得子序列中的最小值乘以子序列所有元素和最大。

2.1 Bad Hair Day

这题目题意：从左到右，每头牛能看到后面多少个牛的头，前面的要比后面的高，注意一样高度时是不能看到的。

#include<stdio.h>
#include<stack>
using namespace std;
const int maxn=8e4+10;
int main()
{
    stack<int>st;
    int n;
	scanf("%d",&n);
	long long ans;
	ans = 0;
	int x;
	for(int i = 1;i <= n;i++){
    scanf("%d",&x);
      while(!st.empty()&&st.top()<= x) st.pop();
      ans = ans + st.size();///想清楚这里
      st.push(x);
	}
	printf("%lld\n",ans);
	return 0;
}

2.2 Largest Rectangle in a Histogram

在这里插入图片描述
题意：输入n个矩形的高度，找出最大矩形面积，如果是合并区间的矩形则以最小的矩形高度为基准乘以他们的宽度。这题就是给定一序列，寻找某一子序列使得子序列中的最小值乘以子序列的长度最长。

#include<stdio.h>
#include<stack>
#include<algorithm>
using namespace std;
const int maxn=1e5+10;
long long arr[maxn];
int L[maxn];
int R[maxn];
int main()
{
    int n;
    while(~scanf("%d",&n)&& n){
        stack<int>st;
        for(int i=1;i<=n;i++){///从左往右找递增区间起点
            scanf("%lld",&arr[i]);
            while(!st.empty()&&arr[st.top()]>= arr[i]) st.pop();
            if(st.empty()) L[i] = 1;
            else L[i] = st.top()+1;
            st.push(i);
        }
        while(!st.empty()) st.pop();///清空栈重新存储
        for(int i=n;i>=1;i--){///从右往左找递增区间终点
            while(!st.empty()&&arr[st.top()]>= arr[i]) st.pop();
            if(st.empty()) R[i] = n;
            else R[i] = st.top()-1;
            st.push(i);
        }
        long long ans = 0;
        for(int i=1;i<=n;i++)
            ans = max(ans,arr[i]*(R[i]-L[i]+1));
        printf("%lld\n",ans);
    }
	return 0;
}

2.3 Feel Good

在这里插入图片描述
题意：求人生中最有价值的时期。
这题就是给定一序列，寻找某一子序列使得子序列中的最小值乘以子序列所有元素和最大。

#include<stdio.h>
#include<stack>
#include<algorithm>
using namespace std;
const int maxn = 1e5+10;
int arr[maxn];
int L[maxn];
int R[maxn];
long long sum[maxn]={0};
int main(){
    int n;
    stack<int>st;
    scanf("%d",&n);
    sum[0] = 0;
    for(int i=1;i<=n;i++){
        scanf("%d",&arr[i]);
         sum[i] = sum[i-1] +arr[i];
        while(!st.empty()&&arr[st.top()]>=arr[i]) st.pop();
        if(st.empty()) L[i]=1;
        else L[i]=st.top()+1;
        st.push(i);
    }
    while(!st.empty()) st.pop();
     for(int i=n;i>=1;i--){
        while(!st.empty()&&arr[st.top()]>=arr[i]) st.pop();
        if(st.empty()) R[i]=n;
        else R[i]=st.top()-1;
        st.push(i);
    }
    long long temp;
    long long ans = -1;///记得从初始化为-1
    int x;
    for(int i=1;i<=n;i++){
         temp = arr[i]*(sum[R[i]] - sum[L[i]-1]);
         if(ans<temp){
            ans = temp;
            x=i;
         }
    }
    printf("%lld\n%d %d\n",ans,L[x],R[x]);
    return 0;
}