单调队列入门

求1~m全覆盖的最短区间

651. 逛画展

#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
typedef long long ll;
const double PI = acos(-1.0);
const int maxn = 1e6+5;
const int INF = 0x3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
using namespace std;
int a[maxn];
int vis[maxn];
int q[maxn];
int n,m;
int head,tail,ansa,ansb,cnt,ans;
int main()
{

    scanf("%d%d",&n,&m);
    for(int i = 1; i<=n; i++)
        scanf("%d",&a[i]);
    head = 1;
    tail = 0;
    ansa = ansb = ans = INF;
    cnt = 0;
    for(int i = 1; i<=n; i++)
    {
        if(!vis[a[i]])
            cnt++;
        tail++;
        vis[a[i]]++;
        while(vis[a[head]]>1)
        {
            vis[a[head]]--;
            head++;
        }
        if(cnt>=m && tail-head+1<ans)
        {
            ansa = head;
            ansb = tail;
            ans = tail-head+1;
        }
    }
    cout<<ansa<<" "<<ansb<<endl;


    return 0;
}

求长度不超过m的最大区间和

652. 切蛋糕

/**
    n个数求最大连续子序列的和，长度不超过k。
    普通的dp转移方程就是 dp[i] = sum[i] - min(sum[j] | i - m <= j <= i)
    枚举复杂度为n^2，维护队列存下距离不超过m，且最小的前缀和的下标。
    如果来了一个前缀和，肯定下标是比在队列里的是靠后的。
    如果它的值还比队列里的小，那么队列里的元素就没有必要存在了，就pop掉。
    因为每个元素最多只会进一次队列，出一次队列，所以复杂度就是O(n)。
**/
#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
typedef long long ll;
const double PI = acos(-1.0);
const int maxn = 500005;
const int INF = 0x3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
using namespace std;
int a[maxn];
int sum[maxn];
int ans;
int n,m;
deque<int>q;
int main()
{
    cin>>n>>m;
    for(int i = 1; i<=n; i++)
    {
        cin>>a[i];
        sum[i] = sum[i-1]+a[i];
    }
    ans = -INF;
    q.push_back(0);
    for(int i = 1; i<=n; i++)
    {
        while(q.size() && q.front()<i-m)
            q.pop_front();
        while(q.size() && sum[i]<=sum[q.back()])
            q.pop_back();
        q.push_back(i);
        if(q.size())
            ans = max(ans,sum[i]-sum[q.front()]);
    }
    cout<<ans<<endl;


    return 0;
}

求左右两边第一个未被比ai大的元素挡住的 小于ai的元素下标

HDU - 3410

/**
　　单调队列。
　　先从左向右维护一个单调队列，
    然后在维护过程中最后一个从队列中剔除掉的即右边比它小的数中最大的那一个。
　　单调队列中的值是下标值。
　　从右向左再维护一个单调队列就可以求出另一个值。

    维护一个单调递减队列，将a[i]入队，
    若队尾有元素出队，则最后一个出队的就是所求区间最大值；
    若没有元素出队，则说明满足条件的左区间不存在，存入0就行了。
**/
#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <iostream>
#include <map>
#include <vector>
#include <queue>
#include <set>
#define eps 1e-8
typedef long long ll;
const double PI = acos(-1.0);
const int maxn = 1e6;
const int INF = 0x3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
using namespace std;
int a[maxn];
int ansa[maxn],ansb[maxn];
int q[maxn];
int n;
int main()
{
    //ios::sync_with_stdio(false);
    int T;
    scanf("%d",&T);
    int tt = 1;
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i = 1; i<=n; i++)
            scanf("%d",&a[i]);
        memset(q,0,sizeof q);
        int l = 0,r = -1;
        int flag;
        for(int i = 1; i<=n; i++)
        {
            flag = 0;
            while(l<=r && a[q[r]]<a[i])
            {
                flag = 1;
                r--;
            }
            if(flag)
                ansa[i] = q[r+1];
            else
                ansa[i] = 0;
            q[++r] = i;
        }
        for(int i = n; i>=1; i--)
        {
            flag = 0;
            while(l<=r && a[q[r]]<a[i])
            {
                flag = 1;
                r--;
            }
            if(flag)
                ansb[i] = q[r+1];
            else
                ansb[i] = 0;
            q[++r] = i;
        }
        printf("Case %d:\n",tt++);
        for(int i = 1; i<=n; i++)
            cout<<ansa[i]<<" "<<ansb[i]<<endl;
    }
    return 0;
}