ZOJ1232 Adventure of Super Mario（DP+SPFA）

dp[u][t]表示从起点出发，到达i点且用了t次magic boot时的最短时间，

方程如下：

dp[v][t]=min(dp[v][t],dp[u][t]+dis[u][v]);

dp[v][t]=min(dp[v][t],dp[u][t-1]) (dis[u][v]<=l)

放进SPFA更新，相当于一个二维的最短路，解决DP在非DAG下的有后效性的问题。

 #include<cstdio>
 #include<cstring>
 #include<queue>
 #include<algorithm>
 using namespace std;
 #define MAXN 111
 #define INF (1<<29)

 int n,a,b,m,l,k;
 int map[MAXN][MAXN],dis[MAXN][MAXN];

 void Floyd(){
     memcpy(dis,map,sizeof(map));
     for(int k=; k<=a; ++k){
         for(int i=; i<=n; ++i){
             for(int j=; j<=n; ++j){
                 if(dis[i][k]==INF || dis[k][j]==INF) continue;
                 dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
             }
         }
     }
 }

 struct QNode{
     int u,t;
     QNode(int _u=,int _t=):u(_u),t(_t){}
 };
 int dp[MAXN][];
 bool vis[MAXN][];
 void SPFA(){
     memset(vis,,sizeof(vis));
     vis[n][]=;
     for(int i=; i<=n; ++i){
         for(int j=; j<; ++j) dp[i][j]=INF;
     }
     dp[n][]=;
     queue<QNode> que;
     que.push(QNode(n,));
     while(!que.empty()){
         int u=que.front().u,t=que.front().t;
         que.pop();
         for(int v=; v<=n; ++v){
             if(dp[v][t]>dp[u][t]+dis[u][v]){
                 dp[v][t]=dp[u][t]+dis[u][v];
                 if(!vis[v][t]){
                     vis[v][t]=;
                     que.push(QNode(v,t));
                 }
             }
         }
         for(int v=; t!=k && v<=n; ++v){
             if(dis[u][v]<=l && dp[v][t+]>dp[u][t]){
                 dp[v][t+]=dp[u][t];
                 if(!vis[v][t+]){
                     vis[v][t+]=;
                     que.push(QNode(v,t+));
                 }
             }
         }
         vis[u][t]=;
     }
 }

 int main(){
     int t,u,v,w;
     scanf("%d",&t);
     while(t--){
         scanf("%d%d%d%d%d",&a,&b,&m,&l,&k);
         n=a+b;
         for(int i=; i<=n; ++i){
             for(int j=; j<=n; ++j) map[i][j]=INF;
         }
         while(m--){
             scanf("%d%d%d",&u,&v,&w);
             map[u][v]=map[v][u]=min(map[u][v],w);
         }
         Floyd();
         SPFA();
         int res=INF;
         for(int i=; i<=k; ++i){
             res=min(res,dp[][i]);
         }
         printf("%d\n",res);
     }
     return ;
 }