hdu 4362

单调队列优化dp，主要是去除绝对值时，分为两种情况。排完序后，利用单调性可以减少复杂度。具体看代码。

#include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
typedef struct
{
    int x,val;
}Node;
Node L[1010],R[1010]; Node Ball[51][1010];
int f[51][1010];

int cmp1(const Node &a,const Node &b)
{
    if( a.x==b.x ) return a.val<b.val;
    return a.x<b.x;
}

int cmp2(const Node &a,const Node &b)
{
    if( a.val==b.val ) return a.x<b.x;
    return a.val<b.val;
}

int main()
{
    int T,i,j,n,m,x; int head,tail,ans1,ans2,k;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&m,&n,&x);
        for(i=1;i<=m;i++)
            for(j=1;j<=n;j++)
                scanf("%d",&Ball[i][j].x);
        for(i=1;i<=m;i++)
            for(j=1;j<=n;j++)
                scanf("%d",&Ball[i][j].val);
        for(i=1;i<=m;i++)
            sort(Ball[i]+1,Ball[i]+n+1,cmp1);
        for(i=1;i<=n;i++)
            f[1][i]=abs(Ball[1][i].x-x)+Ball[1][i].val;
        for(i=2;i<=m;i++)
        {
            for(j=1;j<=n;j++)
            {
                L[j].val=f[i-1][j]-Ball[i-1][j].x;
                R[j].val=f[i-1][j]+Ball[i-1][j].x;
                L[j].x=R[j].x=Ball[i-1][j].x;
            }
            sort(R+1,R+n+1,cmp2);
            int mn=1000000000; int h=1,k=1; int ans1,ans2;
            ans1=ans2=1000000000;
            for(j=1;j<=n;j++)
            {
                while(L[h].x<=Ball[i][j].x && h<=n )
                {
                    if( L[h].val < mn )  mn=L[h].val;
                    h++;
                }
                ans1=mn+Ball[i][j].x+Ball[i][j].val;
                while( R[k].x < Ball[i][j].x  && k<=n) k++;
                if(k==n+1) ans2=1<<31-1;
                else
                ans2=R[k].val+Ball[i][j].val-Ball[i][j].x;
                f[i][j]=min( ans1,ans2 );
            }
        }
        int temp=1000000000;
        for( i=1;i<=n;i++ )
        {
            if( f[m][i]<temp )
                temp=f[m][i];
        }
        printf("%d\n",temp);
    }
    return 0;
}