UVA 10269 Adventure of Super Mario 最短路

         题意：有A个村庄和B个城堡，1~A为村庄，A+1~A+B为城堡，马里奥在A+B，他要到1，图为无向图，马里奥可以用走的，也可以用加速鞋，加速鞋可以让马里奥瞬间移动不超过L，但是他不可以穿越城堡，也就是说如果他加速，那么遇到城堡就要停下来，加速的起点和终点必须是城堡或者村庄。问你从起点到终点的最少时间花费。

         思路：这道题有点像uva 11367 Full Tank?  不过那道题我没写题解- - 这种题虽然是最短路，但不能直接套模板，因为状态不是一维的，还有一个状态就是使用加速鞋的次数，即到达一个点可以选择是否使用加速鞋（在使用次数允许的范围内）。 用floyed处理出任意两点最短路，但是k从1到A，这样就保证了不会用加速鞋穿过城堡的问题。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;

const int maxn = 100 + 10;
const int INF = 0x3f3f3f3f;

struct Edge{
     int u, d;
     int use;
     Edge(int u = 0, int d = 0, int use = 0) : u(u), d(d), use(use) {}
     bool operator < (const Edge &rhs) const{
          return d > rhs.d;
     }
};

int A, B, m;
int L, k;
int floyed[maxn][maxn];
int vis[maxn][15];
int dist[maxn][15]; //到达第i个地点 使用了j次加速 到达目标状态的最小值
vector<pair<int, int> > G[maxn];

int dijkstra(){
     memset(dist, INF, sizeof(dist));
     memset(vis, 0, sizeof(vis));
     priority_queue<Edge> Q;
     Q.push(Edge(A + B, 0, 0));
     dist[A+B][0] = 0;
     while(!Q.empty()){
          Edge cur = Q.top(); Q.pop();
          int u = cur.u;
          int use = cur.use;
          if(vis[u][use]) continue;
          vis[u][use] = 1;
          for(int i = 0; i < (int)G[u].size(); i++){ //不使用加速
               int v = G[u][i].first;
               int d = G[u][i].second;
               if(dist[v][use] > dist[u][use] + d){
                    dist[v][use] = dist[u][use] + d;
                    Q.push(Edge(v, dist[v][use], use));
               }
          }
          if(use < k){ //使用加速
               for(int v = 1; v <= A + B; v++)if(v != u){
                    if(floyed[u][v] <= L && dist[v][use+1] > dist[u][use]){
                         dist[v][use+1] = dist[u][use];
                         Q.push(Edge(v, dist[v][use+1], use + 1));
                    }
               }
          }
     }
     int ans = INF;
     for(int i = 0; i <= k; i++)
          ans = min(ans, dist[1][i]);
     return ans;
}

void Floyed(){
     for(int k = 1; k <= A; k++)
          for(int i = 1; i <= A + B; i++)
               for(int j = 1; j <= A + B; j++)
                    if(floyed[i][k] != INF && floyed[k][j] != INF)
                    floyed[i][j] = min(floyed[i][j], floyed[i][k] + floyed[k][j]);
}

void solve(){
     scanf("%d%d%d%d%d", &A, &B, &m, &L, &k);
     for(int i = 1; i <= A + B; i++) G[i].clear();
     memset(floyed, INF, sizeof(floyed));
     for(int i = 0; i < m; i++){
          int u, v, d;
          scanf("%d%d%d", &u, &v, &d);
          G[u].push_back(make_pair(v, d));
          G[v].push_back(make_pair(u, d));
          if(floyed[u][v] == 0) floyed[u][v] = floyed[v][u] = d;
          else floyed[u][v] = floyed[v][u] = min(floyed[u][v], d);
     }
     Floyed();
     printf("%d\n", dijkstra());
}

int main()
{
     int T;
     scanf("%d", &T);
     while(T--) solve();
     return 0;
}