UVa 1025 -A Spy in the Metro(动态规划）

      按照红书学的动态规划，红书先讲的数字三角形和DAG上的动态规划问题，介绍了记忆化搜索和递推这两种方法，我感觉记忆化搜索比较好理解些，书上写动态规划的核心是状态和状态转移方程，对这个理解的不太还好

      动态规化刷的第一题，书上是这么分析的，时间是单向流逝的，是一个天然的 ‘序’，影响的决策的只有当前的时间和所处的车站，用d(i,j)表示时刻i，车站j，最少还需要等待多长时间，边界是d(T,n)=0，其他d(T,i)(i不等于n）为正无穷有如下三种决策：

      决策1：等一分钟

      决策2：搭乘往右的车（如果有）

      决策3：搭乘往左的车（如果有）

      看了解析后感觉这和数字三角形比较相似，逆推，每一次都根据之前已经推出来的最优决策来选择当前状态的最优决策，此题的hastrain数组用的比较巧妙

      

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <string>
#include <vector>
#include <queue>
#include <stack> 
#include <set>
#include <map>
using namespace std;
const int INF=0x3f3f3f3f;
int t[60],dp[250][60],has_train[100000][60][2];
//dp是在i时刻，j车站还需要等待多长时间 
int main(void)
{
	int n,T;
	int M1,M2;
	int Case=0;
	while(scanf("%d",&n)!=EOF&&n)
	{
		scanf("%d",&T);
		//从车站i到i+1的时间 
		for(int i=1;i<n;i++)
		    scanf("%d",&t[i]);
		memset(has_train,0,sizeof(has_train));
		memset(dp,0,sizeof(dp));
		scanf("%d",&M1);
		//hastrain数组，记录在i时刻j车站是否有火车
		//0是向右的火车，1是向左的火车 
		for(int i=1;i<=M1;i++)
		{
			int st;
			scanf("%d",&st);
			int k=st;
			for(int j=1;j<=n;j++)
			{
				has_train[k][j][0]=1;
				k+=t[j];
			}
		}
		scanf("%d",&M2);
		for(int i=1;i<=M2;i++)
		{
			int st;
			scanf("%d",&st);
			int k=st;
			for(int j=n;j>=1;j--)
			{
				has_train[k][j][1]=1;
				k+=t[j-1];
			}
		}
		//在T时刻，如果没有到达车站n的话，就不可能到达了，所以设值为无穷大 
		for(int i=1;i<=n-1;i++) dp[T][i]=INF;
		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;  //等待一个单位
			   //判断是否有向右开的地铁，当j=n是无需判断	   
		   	   if(j<n&&has_train[i][j][0]&&i+t[j]<=T) 
				  dp[i][j]=min(dp[i][j],dp[i+t[j]][j+1]);
			   //判断是否有向左开的地铁  ，当j=1时无需判断 
			   if(j>1&&has_train[i][j][1]&&i+t[j-1]<=T)
			      dp[i][j]=min(dp[i][j],dp[i+t[j-1]][j-1]);	   
		   }
		
		printf("Case Number %d: ",++Case);
		if(dp[0][1]>=INF) printf("impossible\n");
		else printf("%d\n",dp[0][1]); 
	}
	return 0;
}