UVA 1025 A Spy in the Metro dp

题目链接：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3466

这是一道dp题目，作为菜鸟的我刚知道他叫DAG上的动态规划，DAG就是一种图吧，这个题的题义也可以大体看成一个图，N个点，这N个点连起来，

说一下题意某某某在1号车站，想去N号车站去会见一个人，然后他想尽量多的在车上度过，在站台转车不需要耗费时间，给你两个时间表，分别是从第一个车站->最后一个车站从第一个车站发车时间，从左后一个车站开往第一个车站从最后一个车站发车时间，另外还给你了从n-1 --- n 车站之间需要花费的时间，然后去求他需要在车站呆的最短时间

输入实例：

N             -------------N个车站

T              ---------------约定的时间

t1,t2,t3,t4 ----------------路上的时间 ti 代表i 和 i+1 车站之间

M1          ----------------1车站发车 有多少个时间点

d1,d2,d3,d4   --------------------1车站发车的时间点

M2   --------------------n车站发车有多少个时间点

e1,e2,e3,e4   --------------------n车站发车的时间点

、

然后说一下dp策略：

开一个二维数组，dp[i][j]表示i时刻，在j车站最少等待时间，那么一点时间也没用的时候dp[T][N]就是等于0，其他的INF就行，既然是剩余时间，就那么就从后往前找，每个点都是三种情况，要么我在上一点的基础上等待一分钟，要么就上车往左，要么就上车往右，如还迷茫  来看下代码试试

对啦，我想说一下为什么时间要倒着来，书上给的是时间是一个天然的“序”，我一点都不理解，还有最后为什么输出的是dp[0][1]，更是惊讶，有没有大牛看到这篇文章 给我讲讲

My ugly code

//
//  main.cpp
//  C_workspace
//
//  Created by ldu on 2017/10/13.
//  Copyright © 2017年 ldu. All rights reserved.
//

#include <iostream>
#include <cmath>
#include <cstring>
#include <string>
#include <cstdio>
#include <algorithm>

using namespace std;
const int maxn=550;

int N,T,t[maxn],M1,d[maxn],M2,e[maxn];
bool hasR[maxn][maxn],hasL[maxn][maxn];
int dp[maxn][maxn];
int cas=1;

int main() {
    
    while(~scanf("%d",&N)&&N){
        scanf("%d",&T);
        for(int i=1;i<=N-1;i++){
            scanf("%d",&t[i]);
        }
        scanf("%d",&M1);
        for (int i=1; i<=M1; i++) {
            scanf("%d",&d[i]);
        }
        scanf("%d",&M2);
        for (int i=1; i<=M2; i++) {
            scanf("%d",&e[i]);
        }
        /*开始处理发车时间*/
        memset(hasR, false,sizeof(hasR));
        memset(hasL, false, sizeof(hasL));
        int tim;
        for(int i=1;i<=M1;i++){
            /*1-》n 方向*/
            tim=d[i];
            for(int j=1;j<=N;j++){
                hasR[tim][j]=true;
                if(j != N) tim+=t[j];
            }
        }
        for(int i=1;i<=M2;i++){
            tim=e[i];
            /*n -》 1 方向*/
            for(int j=N;j>=1;j--){
                hasL[tim][j]=true;
                if(j != 1) tim+=t[j-1];
            }
        }
        
        memset(dp, 0x3f, sizeof(dp));
        dp[T][N]=0;
        for (int i=T-1;i>=0 ; i--) {
            for(int j=1;j<=N;j++){
                /*三种情况处理*/
                dp[i][j]=dp[i+1][j]+1;
                
                if( j < N && i+t[j] <=T && hasR[i][j]){
                    dp[i][j]=min(dp[i][j],dp[i+t[j]][j+1]);
                }
                if( j > 1 && i+t[j-1] <=T && hasL[i][j] ){
                    dp[i][j]=min(dp[i][j],dp[i+t[j-1]][j-1]);
                }
            }
        }
        /*最后我们要的是把时间花费干净，然后就是dp[0][1]*/
        printf("Case Number %d: ",cas++);
        if(dp[0][1] >= 0x3f3f3f3f) printf("impossible\n");
        else printf("%d\n",dp[0][1]);
    }
}