UVA 12170--Easy Climb（dp+优先队列）

题意：给了n个堆的高度，要求改变堆的高度，首位不可变，使得队列的任意相邻的两数之差<=d,求最小代价

思路：一开始完全没有思路，比较难，然后看题解，看题解看了半天才看懂，还要加预处理，再就是转化成优先队列的问题,还有就是用到了滚动数组。

通过枚举可以发觉每个数字只能变成h[i]+k*d这种形式的数字，每个数的状态只有n^2个了，不过转移的话代价比较高，因为对于d(i,x)需要枚举d(i-1,y)| x - d <= y <= x+d最小的转移过来，其实这个就是相当于一个求区间最值的问题，我们可以利用单调队列做到线性的，下标递增，值也是递增的，这是左边界的处理，右边界的话，就看是否满足x-d<=y即可。不满足就让队尾的出队，直至满足为止。

感想：很吃屎的是，一直wa，最后跟着题解改，改的一样了还是WA，最后发现是定义数组的顺序？？？？？实在不敢相信,又把原先的wa的代码的数组顺序改了一下就A了？？？？？我很是蒙蔽？？？

代码：

#include<bits/stdc++.h>
using namespace std;

long long dp[2][20010],pos[20010],d,INF=1e15;///顺序变了会WA？？？？
long long n,m,h[110],t,ans,x,all;
int fin(long long zz)
{
   int l=1,r=all,mid;
   while(l<r)
   {
       mid=(l+r)/2;
       if(pos[mid]<zz)
        l=mid+1;
       else r=mid;
   }
   return l;
}
struct AA
{
    long long x,l;

}ff[50010];
int main()
{
    scanf("%lld",&t);
    while(t--)
    {
        scanf("%lld%lld",&n,&d);
        all=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&h[i]);
            for(int k=-n;k<=n;k++)
            {
                x=h[i]+k*d;///每个堆的高度的可能性
                if(x>=0) pos[++all]=x;
            }
        }
        sort(pos+1,pos+1+all);///排序去重

        int l=1;
        for(int i=2;i<=all;i++)
        {
            if(pos[l]!=pos[i])
                pos[++l]=pos[i];
        }
        all=l;

        for(int i=1;i<=all;i++)///赋初值
        {
            dp[0][i]=INF;
        }
        dp[0][fin(h[1])]=0;///第一个位置为0
        int a,b,k,head,tail;
        for(int i=2;i<=n;i++)///枚举每一个堆
        {
            if(i&1) {a=1;b=0;}///滚动数组，a是上一个，b是当前的
            else {a=0;b=1;}
            k=1;
            head=tail=20000;
            for(int j=1;j<=all;j++)///枚举每一个可能点
            {
                dp[b][j]=INF;
                while(pos[k]-pos[j]<=d&&k<=all)///优先队列，能放的放
                {
                    while(tail>head&&dp[a][k]<=ff[tail-1].x) tail--;
                    ff[tail].x=dp[a][k];
                    ff[tail].l=k;
                    k++;
                    tail++;
                }
                while(pos[ff[head].l]-pos[j]<-d) head++;
                dp[b][j]=abs(h[i]-pos[j])+ff[head].x;
            }
        }
        ans=dp[b][fin(h[n])];
        if(ans>=INF) printf("impossible\n");
        else printf("%lld\n",ans);
    }
}