POJ 1661

#include
#include
#include

using namespace std;


const int maxn=1010;

int t,n,s1,s2,maxs;

typedef struct name
{
     int x1,x2,h;
}jimmy;

jimmy a[maxn];

int dp[maxn][2];

const int INF=9999999;


bool cmp(jimmy a,jimmy b)
{
    if(a.h0&&a[i].h-a[k].h<=maxs)
    {
        if(a[i].x1>=a[k].x1&&a[i].x1<=a[k].x2)
        {
          dp[i][0]=a[i].h-a[k].h+min(a[i].x1-a[k].x1+dp[k][0],a[k].x2-a[i].x1+dp[k][1]);
          return 0;
        }
        else
            k--;
    }
    if(a[i].h-a[k].h>maxs)
        dp[i][0]=INF;
     else
        dp[i][0]=a[i].h;
}


int rightmin(int i)
{
    int k=i-1;
    while(k>0&&a[i].h-a[k].h<=maxs)
    {
        if(a[i].x2>=a[k].x1&&a[i].x2<=a[k].x2)
        {
            dp[i][1]=a[i].h-a[k].h+min(a[i].x2-a[k].x1+dp[k][0],a[k].x2-a[i].x2+dp[k][1]);
            return 0;
        }
        else
            k--;
    }
    if(a[i].h-a[k].h>maxs)
        dp[i][1]=INF;
    else
        dp[i][1]=a[i].h;
}


int shorttime()
{
    int i;
    for(int i=1;i<=n+1;i++)
    {
        leftmin(i);
        rightmin(i);
    }
    return min(dp[n+1][0],dp[n+1][1]);
}


int main()
{
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d%d%d",&n,&s1,&s2,&maxs);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d",&a[i].x1,&a[i].x2,&a[i].h);
        }
        a[0].x1=-20000;
        a[0].x2=20000;
        a[0].h=0;
        a[n+1].x1=s1;
        a[n+1].x2=s1;
        a[n+1].h=s2;
        sort(a,a+n+2,cmp);
        /*for(int i=0;i<=n+1;i++)
            printf("%d  %d  %d\n",a[i].x1,a[i].x2,a[i].h);*/
        printf("%d\n",shorttime());
    }
    return 0;
}

这个题目还是一个记忆化搜索，对现在的我来说还是感觉比较难啊，虽然一开始想到了应该是这种问题，但是如何设立dp数组没有想到能那么精妙，这就是也个难点了啊，

让人很是苦恼的啊，然后难点就是循环i：1-n+1然后求解每层的i的对向左还是向右走的选择的算的的dp的值了。这些也需要一定的技巧特别是对底层的处理。然后看别人的

解题报告还是能学到不少的，我是从这个博客里学的  http://blog.csdn.net/jdplus/article/details/19919531     然后就是学习了一哈那个qsort的用法，网上学习资料

很多，随便找了一篇这个的，http://blog.csdn.net/ncs12/article/details/24139189   发现这个qsort的用法和sort的用法还是有很多不一样的，那个当 > < =  三者的

情况下的对排序结果的处理都是不同的，这点倒是qsort的好处啊。