POJ 1661 Help Jimmy 最短路或者dp

Help Jimmy" 是在下图所示的场景上完成的游戏。

场景中包括多个长度和高度各不相同的平台。地面是最低的平台，高度为零，长度无限。

Jimmy老鼠在时刻0从高于所有平台的某处开始下落，它的下落速度始终为1米/秒。当Jimmy落到某个平台上时，游戏者选择让它向左还是向右跑，它跑动的速度也是1米/秒。当Jimmy跑到平台的边缘时，开始继续下落。Jimmy每次下落的高度不能超过MAX米，不然就会摔死，游戏也会结束。

设计一个程序，计算Jimmy到底地面时可能的最早时间。

Input

第一行是测试数据的组数t（0 <= t <= 20）。每组测试数据的第一行是四个整数N，X，Y，MAX，用空格分隔。N是平台的数目（不包括地面），X和Y是Jimmy开始下落的位置的横竖坐标，MAX是一次下落的最大高度。接下来的N行每行描述一个平台，包括三个整数，X1[i]，X2[i]和H[i]。H[i]表示平台的高度，X1[i]和X2[i]表示平台左右端点的横坐标。1 <= N <= 1000，-20000 <= X, X1[i], X2[i] <= 20000，0 < H[i] < Y <= 20000（i = 1..N）。所有坐标的单位都是米。

Jimmy的大小和平台的厚度均忽略不计。如果Jimmy恰好落在某个平台的边缘，被视为落在平台上。所有的平台均不重叠或相连。测试数据保证问题一定有解。

Output

对输入的每组测试数据，输出一个整数，Jimmy到底地面时可能的最早时间。

Sample Input

1
3 8 17 20
0 10 8
0 10 13
4 14 3

第一种方法：最短路。

我们对线段进行排序后，每条线段有两个点。如果这条线段下面那条线段距离满足条件，那么分两种情况。如果下面线段L小于上面的L，R大于上面的L。那么我们就让连接上面的L和下面的L和R，两条线段。 同理上面的R也要判断后连接。最后我们求最短路即可

参考地址：http://www.cnblogs.com/chenxiwenruo/p/3529252.html

第二种方法：DP

DP[i][j]   j=0/1  代表从i号平台走左边到底和走右边到底的最短距离

DP[i][0] = H[i]-H[m]+max(dp[m][0]+x1[i]-x1[m]，dp[m][1]+x2[i]-x1[m]）

DP[i][1] = H[i]-H[m]+max(dp[m][0]+x2[i]-x1[m]，dp[m][1]+x2[i]-x2[m]）

方法一：

#include
#include
#include
#include
#include
#include


using namespace std;
const int maxn=1000*2+5;
const int INF=0x3f3f3f3f;
int N,X,Y,MAX;
long long dis[maxn];
int vis[maxn];  
int head[maxn];
int tot;
long long ans;  
struct Line {
    int l,r,h;
    bool operator<(const Line tmp)const {
        return h>tmp.h;
    }
} line[maxn];
struct Node {
    int u;
    long long dis;
    bool operator<(const Node tmp)const {
        return dis>tmp.dis;
    }
};


struct Edge {
    int to,next;
    int length;
} edge[maxn*maxn];


void add(int i,int j,int dis) {
    edge[tot].next=head[i];
    edge[tot].to=j;
    edge[tot].length=dis;
    head[i]=tot++;
}
void dijkstra(int s) {
    for(int i=0; i         dis[i]=INF;
        vis[i]=0;
    }
    priority_queueq;
    Node t;
    t.u=s;
    t.dis=0;
    dis[s]=0;
    q.push(t);
    int v,u;
    while(!q.empty()) {
        t=q.top();
        q.pop();
        u=t.u;
        vis[u]=1;


        if(u==2*N+1){
            ans=t.dis;
            break;
        }


        for(int k=head[u]; k!=-1; k=edge[k].next) {
            v=edge[k].to;
            if(!vis[v] && dis[u]+edge[k].length                 dis[v]=dis[u]+edge[k].length;
                t.u=v;
                t.dis=dis[v];
                q.push(t);
            }




        }
    }
}
int main() {
    int t;
    scanf("%d",&t);
    while(t--) {
        memset(head,-1,sizeof(head));
        tot=0;
        scanf("%d%d%d%d",&N,&X,&Y,&MAX);
        for(int i=1; i<=N; i++) {
            scanf("%d%d%d",&line[i].l,&line[i].r,&line[i].h);
        }
        sort(line+1,line+N+1);
        int ldis,rdis;
        for(int i=1; i<=N; i++) {
            //这里要考虑，不是所有在i平台下方符合的就可以建立边的关系
            //而只能与它最近的平台才行。
            //例如平台1,2,3，并且2、3都在1的下方，且满足条件。但1和3不能相连，因为中间隔着2，所以只能1和2相连
            int cnt1=0,cnt2=0;
            for(int j=i+1; j<=N; j++) {
                if(line[i].h-line[j].h>=0 && line[i].h-line[j].h<=MAX) {
                    if(line[j].l<=line[i].l && line[i].l<=line[j].r) {
                        cnt1++;
                        //左端下方第一个符合要求的
                        if(cnt1==1) {
                            ldis=line[i].h-line[j].h+line[i].l-line[j].l;
                            add(i*2-1,j*2-1,ldis);


                            rdis=line[i].h-line[j].h+line[j].r-line[i].l;
                            add(i*2-1,j*2,rdis);
                        }
                    }
                    if(line[j].l<=line[i].r && line[i].r<=line[j].r) {
                        cnt2++;
                        //右端点下方第一个符合要求的
                        if(cnt2==1) {
                            ldis=line[i].h-line[j].h+line[i].r-line[j].l;
                            add(i*2,j*2-1,ldis);


                            rdis=line[i].h-line[j].h+line[j].r-line[i].r;
                            add(i*2,j*2,rdis);
                        }
                    }
                }
            }
            //若要与地面连接，则必须该平台下方没有其它阻隔的平台。
            //如果该平台左端点下方没有其它平台阻隔，且满足条件，则与地面相连
            if(!cnt1 && line[i].h<=MAX) {
                add(i*2-1,2*N+1,line[i].h);
            }
            //如果该平台右端点下方没有其它平台阻隔，且满足条件，则与地面相连
            if(!cnt2 && line[i].h<=MAX) {
                add(i*2,2*N+1,line[i].h);
            }
        }
        //只能有一个平台与源点连接
        int cnt=0;
        for(int j=1; j<=N; j++) {
            if(line[j].l<=X && X<=line[j].r && Y-line[j].h>=0 && Y-line[j].h<=MAX) {
                cnt++;
                //第一个符合要求的平台
                if(cnt==1) {
                    ldis=Y-line[j].h+X-line[j].l;
                    add(0,j*2-1,ldis);


                    rdis=Y-line[j].h+line[j].r-X;
                    add(0,j*2,rdis);
                }
            }
        }
        //没有平台在jimmy的下方，也就是jimmy可以直接到达地面。。。之前都忽略了额
        if(cnt==0) {
            add(0,2*N+1,Y);
        }
        dijkstra(0);
        printf("%I64d\n",ans);
    }
    return 0;
}

方法二：

 #include
 #include

 #define MAXN 1010
 #define INF 9000000

 typedef struct platform{
     int x1;
     int x2;
     int high;
 }Platform;

 int compare (const void * p, const void * q){
     Platform * p1 = (Platform *)p;
     Platform * q1 = (Platform *)q;
     return p1->high - q1->high;
 }

 int Min (int a, int b){
     return (a < b) ? a : b;
 }

 int N, X, Y, MAX;
 Platform plat[MAXN];
 int dp[MAXN][2];         //dp[i][0]、dp[i][1]分别表示从第i个平台左、右边到地面的最短时间

 void LeftMinTime (int i){    //计算从平台i左边到地面的最短时间
     int k = i - 1;
     while (k > 0 && plat[i].high - plat[k].high <= MAX){
         //如果平台i左边下面有平台，且两者相距不超过MAX
         if (plat[i].x1 >= plat[k].x1 && plat[i].x1 <= plat[k].x2){
             dp[i][0] = plat[i].high - plat[k].high +
                 Min (plat[i].x1 - plat[k].x1 + dp[k][0], plat[k].x2 - plat[i].x1 + dp[k][1]);
             return;
         }
         else
             --k;
     }
     //如果平台i左边下面没有平台，或者两者相距超过了MAX
     if (plat[i].high - plat[k].high > MAX)
         dp[i][0] = INF;
     else
         dp[i][0] = plat[i].high;
 }

 void RightMinTime (int i){   //计算从平台i右边到地面的最短时间
     int k = i - 1;
     while (k > 0 && plat[i].high - plat[k].high <= MAX){
         //如果平台i右边下面有平台，且两者相距不超过MAX
         if (plat[i].x2 >= plat[k].x1 && plat[i].x2 <= plat[k].x2){
             dp[i][1] = plat[i].high - plat[k].high +
                 Min (plat[i].x2 - plat[k].x1 + dp[k][0], plat[k].x2 - plat[i].x2 + dp[k][1]);
             return;
         }
         else
             --k;
     }
     //如果平台i右边下面没有平台，或者两者相距超过了MAX
     if (plat[i].high - plat[k].high > MAX)
         dp[i][1] = INF;
     else
         dp[i][1] = plat[i].high;
 }

 int ShortestTime (){
     int i, j;

     for (i=1; i<=N+1; ++i){
         LeftMinTime (i);
         RightMinTime (i);
     }
     return Min (dp[N+1][0], dp[N+1][1]);
 }

 int main(void){
     int t;
     int i;
     while (scanf ("%d", &t) != EOF){
         while (t-- != 0){
             scanf ("%d%d%d%d", &N, &X, &Y, &MAX);
             for (i=1; i<=N; ++i){
                 scanf ("%d%d%d", &plat[i].x1, &plat[i].x2, &plat[i].high);
             }
             plat[0].high = 0;
             plat[0].x1 = -20000;
             plat[0].x2 = 20000;
             plat[N+1].high = Y;
             plat[N+1].x1 = X;
             plat[N+1].x2 = X;
             //根据平台高度按从低到高排序
             qsort (plat, N+2, sizeof(Platform), compare);
             printf ("%d\n", ShortestTime());
         }
     }

     return 0;
 }