POJ 1661 Help Jimmy （DP）

dp[i][0] dp[i][1] 记录到第i个平台左右两端点时最短时间。

预处理出每个平台左侧，右侧都能到达哪个平台。根据这个关系DP，复杂度N方。

算出起始平台两侧的dp[i][0],dp[i][1]，作为初始条件，向下DP。

注意：

1.只有当下面的平台的值被更新过，才继续向这一侧DP，否则停止。

2.注意起始点直接落地的情况。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define INF 100000000
int N,sx,sy,MH;
int dw[1005][2];
int dp[1005][2];

struct node{
	int l,r,h;
}G[1005];

bool cmp(node a,node b){
	return a.h>b.h;
}

bool In(int x,int l,int r){
	return x>=l&&x<=r;
}

void solve(int src){
	int cur;
	if(dw[src][0]!=-1){
		cur=dw[src][0];
		int tmp=G[src].h-G[cur].h;
		int l1=dp[cur][0],l2=dp[cur][1];
		dp[cur][0]=min(dp[cur][0],dp[src][0]+tmp+G[src].l-G[cur].l);
		dp[cur][1]=min(dp[cur][1],dp[src][0]+tmp+G[cur].r-G[src].l);
		if(l1!=dp[cur][0]||l2!=dp[cur][1]) solve(cur);
	}
	if(dw[src][1]!=-1){
		cur=dw[src][1];
		int tmp=G[src].h-G[cur].h;
		int l1=dp[cur][0],l2=dp[cur][1];
		dp[cur][0]=min(dp[cur][0],dp[src][1]+tmp+G[src].r-G[cur].l);
		dp[cur][1]=min(dp[cur][1],dp[src][1]+tmp+G[cur].r-G[src].r);
		if(l1!=dp[cur][0]||l2!=dp[cur][1]) solve(cur);
	}
}


int main(){
	int T;
	scanf("%d",&T);
	while(T--){
		scanf("%d%d%d%d",&N,&sx,&sy,&MH);
		for(int i=0;i<N;i++){
			scanf("%d%d%d",&G[i].l,&G[i].r,&G[i].h);
		}
		sort(G,G+N,cmp);
		memset(dw,-1,sizeof(dw));
		for(int i=0;i<N;i++){
			dp[i][0]=INF;dp[i][1]=INF;
		}
		for(int i=0;i<N;i++){
			for(int j=i+1;j<N;j++){
				if(G[j].h<G[i].h&&G[i].h-G[j].h<=MH){
					if(dw[i][0]==-1&&In(G[i].l,G[j].l,G[j].r)) dw[i][0]=j;
					if(dw[i][1]==-1&&In(G[i].r,G[j].l,G[j].r)) dw[i][1]=j;
				}
			}
		}
		int res=INF;
		for(int i=0;i<N;i++){
			if(sy>=G[i].h&&sy-G[i].h<=MH&&In(sx,G[i].l,G[i].r)){
				dp[i][0]=sy-G[i].h+sx-G[i].l;
				dp[i][1]=sy-G[i].h+G[i].r-sx;
				solve(i);
				break;
			}
			if(i==N-1&&sy<=MH) res=sy;
		}

		for(int i=0;i<N;i++){
			if(dw[i][0]==-1&&G[i].h<=MH) res=min(res,dp[i][0]+G[i].h);
			if(dw[i][1]==-1&&G[i].h<=MH) res=min(res,dp[i][1]+G[i].h);
		}
		printf("%d\n",res);
	}
	return 0;
}