hdu_4362 Dragon Ball (DP+单调栈)

http://acm.hdu.edu.cn/showproblem.php?pid=4362

题意：
样例解释
1
3 2 5
2 3
4 1
1 3
1 1
1 3
4 2
第一行为Case数.
第二行为n,m,x表示下面有两个n*m的矩阵，x为起始位置。
第一个矩阵的i，j表示i阶段j龙珠出在坐标位置。
第二个矩阵的i,j表示挖第i阶段的j龙珠所消耗的体力
从x移到y需要体力|x-y|
求最小耗费.
思路：
开始只想到O（m*n*n）的DP，可能会超时，YY了一下，剪枝了两个地方，然后就水过了。。。
以下来自官方解题报告

单调队列+DP
设dp[i][j]表示第i批龙珠中取第j个需要花费的最小体力。

dp[i][j] = min{ dp[i-1][k] + abs(pos[i-1][k]-pos[i][j]) } + cost[i][j];

如果枚举k的话总复杂度位m*n*n，会超时。

可以看出若每个状态只由上一层位置在其左边的状态的转移而来的话： 

dp[i][j]

= min { dp[i-1][k] + pos[i][j] - pos[i-1][k] } + cost[i][j]

= min { dp[i-1][k] - pos[i-1][k] } + pos[i][j] + cost[i][j]

dp[i-1][k]-pos[i-1][k]是个确定的值，就是相当于求位置在pos[i][j]左边的上一层状态中值最小的，可以用个单调队列维护。由右边转移来的类似，再处理一遍右边转移来的取最优。

因为要对同一层的点排序，所以总复杂度是m*n*logn。

我的代码:

/*
program:hdu_4362
author:BlackAndWhite
*/
#include<stdio.h>
#include<algorithm>
using namespace std;
struct node
{
    int pos,cost;
}a[51][1005];
int n,m,x,T,ans;
int dp[51][1005],i,j,k;
int q[10005],top,pnt;
int cmp(node a,node b)
{
    if(a.pos==b.pos) return a.cost<b.cost;
    return a.pos<b.pos;
}
int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&x);
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
                scanf("%d",&a[i][j].pos);
        for(i=0;i<n;i++)
            for(j=0;j<m;j++)
                scanf("%d",&a[i][j].cost);
        for(i=0;i<n;i++)
            sort(a[i],a[i]+m,cmp);
        for(j=0;j<m;j++)
            dp[0][j]=abs(x-a[0][j].pos)+a[0][j].cost;
        for(i=1;i<n;i++)
        {
            top=1;k=0;q[0]=0x3ffffff;
            for(j=0;j<m;j++) dp[i][j]=0x7ffffff;
            for(j=0;j<m;j++)
            {
                while(k<m)
                {
                    if(a[i][j].pos<a[i-1][k].pos) break;
                    while(top)
                    if(q[top-1]>dp[i-1][k]-a[i-1][k].pos)
                        top--;
                    else break;
                    q[top++]=dp[i-1][k]-a[i-1][k].pos;
                    k++;
                }
                dp[i][j]=q[0]+a[i][j].pos+a[i][j].cost;
            }
            top=1;k=m-1;q[0]=0x3fffffff;
            for(j=m-1;j>=0;j--)
            {
                while(k>=0)
                {
                    if(a[i][j].pos>a[i-1][k].pos) break;
                    while(top)
                    if(q[top-1]>dp[i-1][k]+a[i-1][k].pos)
                        top--;
                    else break;
                    q[top++]=dp[i-1][k]+a[i-1][k].pos;
                    k--;
                }
                dp[i][j]=min(q[0]-a[i][j].pos+a[i][j].cost,dp[i][j]);
            }
        }
        ans=0x7fffffff;
        for(j=0;j<m;j++)
            ans=min(ans,dp[n-1][j]);
        printf("%d\n",ans);
    }
    return 0;
}