【单调队列+尺取】HDU 3530 Subsequence

acm.hdu.edu.cn/showproblem.php?pid=3530

【题意】

• 给定一个长度为n的序列，问这个序列满足最大值和最小值的差在[m,k]的范围内的最长子区间是多长？

【思路】

• 对于序列中特定的位置j,我们固定右端j考察左端i，发现[i,j]内的最大值随i的增大而非严格递减
• 对于序列中特定的位置j,我们固定右端j考察左端i，发现[i,j]内的最小值随i的增大而非严格递增
• 所以[i,j]内最大值与最小值的差随i的增大而递减
• 对于序列中特定的位置i,我们固定左端i考察右端j，发现[i,j]内的最大值随j的增大而非严格递增
• 对于序列中特定的位置i,我们固定左端i考察右端j，发现[i,j]内的最小值随j的增大而非严格递减
• 所以[i,j]内最大值与最小值的差随i的增大而递增
• 所以我们可以尺取，即如位置j对应的左端为l,那么i+1的从l以后找
• 两个单调队列mx和mn分别维护最大值和最小值
• mx中存放的是a中数的下标（单调递增），对应的a中的数是单调递减
• mn中存放的是a中数的下标（单调递增），对应的a中的数是单调递增
• 当a[mx[lx]]-a[mn[ln]]>k时，出队列的是mx[lx]和mn[ln]较小的一个，这样才能保证最长子区间
• 当a[mx[lx]]-a[mn[ln]]<m时，不需做任何操作，因为差是随左端点的增大而递减的，如果a[mx[lx]]-a[mn[ln]]<m,只能不更新ans

【AC】

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int n,m,k;
 const int maxn=1e5+;
 int a[maxn];
 int mx[maxn],lx,rx;
 int mn[maxn],ln,rn;
 int l,ans;
 int main()
 {
     while(~scanf("%d%d%d",&n,&m,&k))
     {
         for(int i=;i<=n;i++) scanf("%d",&a[i]);
         lx=ln=;rx=rn=;l=;
         ans=;
         for(int i=;i<=n;i++)
         {
             while(lx<=rx&&a[mx[rx]]<=a[i]) rx--;
             mx[++rx]=i;
             while(ln<=rn&&a[mn[rn]]>=a[i]) rn--;
             mn[++rn]=i;
             while(lx<=rx&&ln<=rn&&a[mx[lx]]-a[mn[ln]]>k)
             {
                 if(mx[lx]>=mn[ln])
                 {
                     l=mn[ln];
                     ln++;
                 }
                 else
                 {
                     l=mx[lx];
                     lx++;
                 }
             }
             if(a[mx[lx]]-a[mn[ln]]>=m)
                 ans=max(ans,i-l);
         }
         printf("%d\n",ans);
     }
     return ;
 }

单调队列+尺取

【疑问】

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int n,m,k;
 const int maxn=1e5+;
 int a[maxn];
 int mx[maxn];
 int mn[maxn];
 struct node
 {
     int x;
     int pos;
 }q[maxn];
 bool judge(int mid)
 {
     memset(q,,sizeof(q));
     memset(mx,,sizeof(mx));
     memset(mn,,sizeof(mn));
     int head=,tail=;
     for(int i=;i<=n;i++)
     {
         while(tail>=head&&q[tail].x<a[i]) tail--;
         q[++tail].x=a[i];q[tail].pos=i;
         while(q[head].pos<=i-mid) head++;
         if(i>=mid) mx[i]=q[head].x;
     }

     head=,tail=;
     for(int i=;i<=n;i++)
     {
         while(tail>=head&&q[tail].x>a[i]) tail--;
         q[++tail].x=a[i];q[tail].pos=i;
         while(q[head].pos<=i-mid) head++;
         if(i>=mid) mn[i]=q[head].x;
     }
     for(int i=mid;i<=n;i++)
     {
         if(mx[i]-mn[i]>=m&&mx[i]-mn[i]<=k)
         {
             return true;
         }
     }
     return false;
 }
 int main()
 {
     while(scanf("%d%d%d",&n,&m,&k)!=EOF)
     {
         for(int i=;i<=n;i++)
         {
             scanf("%d",&a[i]);
         }
         int l=,r=n;
         while(l<=r)
         {
             int mid=(l+r)>>;
             if(judge(mid))
             {
                 l=mid+;
             }
             else
             {
                 r=mid-;
             }
         }
         printf("%d\n",l-);
     }
     return ;
 }

WA

不知道这个二分答案，然后用单调队列判断可行性为啥是挂的orz,我感觉没错.....希望哪位仁兄看到了帮忙指点一下，小弟不尽感激~