ZOJ1027 Travelling Fee（DP+SPFA）

给一张有向无环图，边都有花费，从某点到某点走的那条路径上的那一条花费最多的边可以省掉，问从起点到终点的最少花费的多少，

往DP想的话，就可以写出这个状态dp[u][mx]，表示到达u点已经省掉的花费为mx的最少花费。

用SPFA更新转移方程。。或者理解成队列+我为人人的转移。。其实这题这样子也能解有环图。

看了别人博客，发现还有三种解法：

1. 枚举每一条边作为省掉的边，n次SPFA。这方法简洁，可惜想不出= =
2. 跑Dijkstra，根据记录到每一点时的最长边更新，正确性不懂。。
3. Floyd+DP：加个维度，dp^k[01][u][v]，第一维1和0分别表示省和没省最长边的最少花费，dp[1]的转移就是dp[1][u][v]=min(dp[0][u][k]+dp[1][k][v],dp[1][u][k]+dp[0][k][v])，初始dp[1][i][j]=0（<i,j>∈E），好厉害。。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<string>
#include<algorithm>
using namespace std;
#define INF (1<<29)
int n,G[222][222];
int d[222][10001];
bool vis[222][10001];
struct Node{
    int u,mx;
    Node(int _u,int _mx):u(_u),mx(_mx){}
};
void SPFA(int vs){
    for(int i=0; i<n; ++i){
        for(int j=0; j<10001; ++j) d[i][j]=INF;
    }
    d[vs][0]=0;
    memset(vis,0,sizeof(vis));
    vis[vs][0]=1;
    queue<Node> que;
    que.push(Node(vs,0));
    while(!que.empty()){
        Node nd=que.front(); que.pop();
        int u=nd.u,mx=nd.mx;
        for(int v=0; v<n; ++v){
            if(G[u][v]==INF) continue;
            if(G[u][v]>mx && d[v][G[u][v]]>d[u][mx]+mx){
                d[v][G[u][v]]=d[u][mx]+mx;
                if(!vis[v][G[u][v]]){
                    vis[v][G[u][v]]=1;
                    que.push(Node(v,G[u][v]));
                }
            }
            if(d[v][mx]>d[u][mx]+G[u][v]){
                d[v][mx]=d[u][mx]+G[u][v];
                if(!vis[v][mx]){
                    vis[v][mx]=1;
                    que.push(Node(v,mx));
                }
            }
        }
        vis[u][mx]=0;
    }
}
int main(){
    string name[222],x[111],y[111],vs,vt;
    int m,z[111];
    while(cin>>vs>>vt){
        n=0;
        scanf("%d",&m);
        for(int i=0; i<m; ++i){
            cin>>x[i]>>y[i]>>z[i];
            name[n++]=x[i]; name[n++]=y[i];
        }
        sort(name,name+n);
        n=unique(name,name+n)-name;
        for(int i=0; i<n; ++i){
            for(int j=0; j<n; ++j) G[i][j]=INF;
        }
        for(int i=0; i<m; ++i){
            int u=lower_bound(name,name+n,x[i])-name,v=lower_bound(name,name+n,y[i])-name;
            G[u][v]=z[i];
        }
        SPFA(lower_bound(name,name+n,vs)-name);
        int tv=lower_bound(name,name+n,vt)-name;
        int res=INF;
        for(int i=0; i<10001; ++i) res=min(res,d[tv][i]);
        printf("%d
",res);
    }
    return 0;
}