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

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=1; i<=n; ++i){
            for(int j=1; 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=0; i<=k; ++i){
            res=min(res,dp[1][i]);
        }
        printf("%d
",res);
    }
    return 0;
}