HDU

题目链接： Assignment

 题意：

　　给出一个数列，问其中存在多少连续子序列，使得子序列的最大值-最小值<k。

题解：

　　RMQ先处理出每个区间的最大值和最小值(复杂度为:n×logn)，相当于求出了每个区间的最大值-最小值。那么现在我们枚举左端点，二分右端点就可以在n×logn×logn的时间内过。

#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5+9;
int vec[MAX_N];
int dp1[MAX_N][25];
int dp2[MAX_N][25];
long long ans = 0;
int N,M,T;
void ST(int N)
{
    for(int i=1;i<=N;i++) dp1[i][0] = dp2[i][0] = vec[i];
    for(int j=1;(1<<j)<=N;j++)
    {
        for(int i=1;i+(1<<j)-1<=N;i++)
        {
            dp1[i][j] = max(dp1[i][j-1],dp1[i+(1<<j-1)][j-1]);
            dp2[i][j] = min(dp2[i][j-1],dp2[i+(1<<j-1)][j-1]);
        }
    }
}
int RMQ(int l,int r)
{
    int k = 0;
    while(1<<k+1 <= r-l+1) k++;
    int maxn = max(dp1[l][k],dp1[r-(1<<k)+1][k]);
    int minn = min(dp2[l][k],dp2[r-(1<<k)+1][k]);
    return maxn-minn;
}
int main()
{
    cin>>T;
    while(T--)
    {
        cin>>N>>M;
        ans = 0;
        for(int i=1;i<=N;i++) scanf("%d",&vec[i]);
        ST(N);
        for(int i=1;i<=N;i++)
        {
            int l =i,r = N;
            while(l<=r)
            {
                int mid = (l+r)>>1;
                if(RMQ(i,mid) < M) l = mid+1;
                else r = mid-1;
            }
            ans += (l-1) - i +1;
        }
        cout<<ans<<endl;
    }
    return 0;
}

　　还有一种解法是用两个单调队列维护区间的最大和最小值，让我收益颇多@。@！用双端队列构成单调队列，一个维护最大值，一个维护最小值，从左向右枚举右端点。现在我们知道了这个区间的最大值和最小值，如果最大值减去最小值是小于k的则当前的左端点到右端点里面所有的区间都是符合条件的。直到枚举到一个右端点，使得最大值减最小值>=k，则开始移动左端点删去两个队列中左端点的值(如果有的话)，直到区间重新符合条件。用单调队列处理的话复杂度为(O(n))。

#include<bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5+9;
long long vec[MAX_N];
deque<long long> que1,que2;
int main()
{
    long long N,M,T;
    cin>>T;
    while(cin>>N>>M)
    {
        while(!que1.empty()) que1.pop_back();
        while(!que2.empty()) que2.pop_back();
        for(int i=0;i<N;i++) scanf("%lld",&vec[i]);
        int pos = 0;
        long long ans = 0;
        for(int i=0;i<N;i++)
        {
            while(!que1.empty() && que1.back() < vec[i]) que1.pop_back();
            que1.push_back(vec[i]);
            while(!que2.empty() && que2.back() > vec[i]) que2.pop_back();
            que2.push_back(vec[i]);
            while(!que1.empty() && !que2.empty() && que1.front() - que2.front() >= M)
            {
                ans += (i-pos);
                if(que1.front() == vec[pos]) que1.pop_front();
                if(que2.front() == vec[pos]) que2.pop_front();
                pos++;
            }
        }
        while(pos < N)
        {
            ans += (N-pos);
            pos ++;
        }
        cout<<ans<<endl;
    }
    return 0;
}