hdu2992 Hotel booking （floyd+spfa+map）

http://acm.hdu.edu.cn/showproblem.php?pid=2992

题意：有一辆车要送东西从1到n，这辆车体力有限只能连续行驶10小时。不过他可以预先让自己的公司给自己定旅馆，可以在旅馆里恢复体力，问最少可以经过多少旅馆。

ps：这题没做出来，看的别人的。

思路：真是一道好题，不光思路经典，还活用了多种容器。首先整体思路吧。最重要的限制条件是行驶时间，如果时间一到，那么便无法到达，所以必须在时间到以前赶到旅店。那么，我们就不能按照以前的方法建图了，因为每个节点都不一定能到达，那节点还有什么存在的意义？！！所以我们需要建一个新图！

那新图怎么搞呢？如果你是司机，你关注的是城市(普通节点)，还是旅店(特殊节点)，当然是旅店啊，这里城市相当于没有，反正过了也就过了= =。而我们求的是经过最少的旅店数量，把旅店数量当做路径求最短路，所以新图就是这些旅店加上起点终点，通过floyd方法求最短路(别的方法也行)。

这里我们对原图城市上的旅店做一个映射，这里映射当做下标使用，以这些下标为点建图。

那么建图条件就是在10小时之内能到达，才能建立边。如何判断是否能到达？我们用spfa对所有的客栈求到每个点的最短路，如果能到达则建立边。但是就在这里，只有客栈之间建边才有意义(如果建一条通向普通城市的边，不能休息，有卵用啊)。上代码：

    for(int i = 1; i <= n; i++)
    {
        if(dis[i] <= 600)
            G[mp[s]][mp[i]] = 1;
    }

可以看到对城市也建立了边，那岂不是本末倒置？我也想了半天，于是自己试了一下：

#include <map>
#include <iostream>
#include <string>
using namespace std;
int main()
{
	map<int, int> m;
	m[2] = 1;
	m[3] = 2;
	cout << m[4] << endl;//这个输出是0。
    return 0;
}

没有赋值的map初值居然是0？那这样意思就是遇到对城市建立的边，都会指向起点，这样就构成了回路。而我们求的是最短路，所以正环不会影响。

剩下的就是普通操作了，不过要细心，这题居然3种容器都用了。。

#include <stdio.h>
#include <algorithm>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <queue>
#include <vector>
#include <map>

using namespace std;

typedef long long LL;

const int N = 10005;
const int INF = 0x3f3f3f3f;

int G[105][105], dis[N], n, num;
bool inque[N];

struct node
{
    int u, v, w;
};

vector <struct node> edge[N];
map <int, int> mp;

void spfa(int s)
{
    queue<int>que;
    while(!que.empty()) que.pop();
    memset(inque, false, sizeof(inque));
    memset(dis, INF, sizeof(dis));//求最短路记得赋最大值
    inque[s] = true;
    que.push(s);
    dis[s] = 0;
    while(!que.empty())
    {
        int u = que.front();
        que.pop();
        inque[u] = false;
        for(int i = 0; i < edge[u].size(); i++)
        {
            int v = edge[u][i].v;
            if(dis[u]+edge[u][i].w<dis[v])
            {
                dis[v] = dis[u]+edge[u][i].w;
                if(!inque[v])
                {
                    inque[v] = true;
                    que.push(v);
                }
            }
        }
    }
    for(int i = 1; i <= n; i++)
    {
        if(dis[i] <= 600)
            G[mp[s]][mp[i]] = 1;
    }
}

void floyd()
{
    for(int k = 0; k <= num+1; k++)
        for(int i = 0; i <= num+1; i++)
            for(int j = 0; j <= num+1; j++)
            {
                G[i][j] = min(G[i][j], G[i][k]+G[k][j]);
            }
}

void init()
{
    mp.clear();
    for(int i = 1; i <= n; i++)
        edge[i].clear();
    for(int i = 0; i <= num+2; i++)
        for(int j = 0; j <= num+2; j++)
        {
            if(i == j) G[i][j] = 0;
            else G[i][j] = INF;
        }
}

int main()
{
  //  freopen("in.txt", "r", stdin);
    int m, u, v, w, a[105];
    while(~scanf("%d", &n))
    {
        if(n == 0) break;
        scanf("%d", &num);
        init();
        for(int i = 1; i <= num; i++)
        {
            scanf("%d", &a[i]);
            mp[a[i]] = i;
        }
        scanf("%d", &m);
        for(int i = 1; i <= m; i++)
        {
            scanf("%d%d%d", &u, &v, &w);
            edge[u].push_back((struct node){u, v, w});
            edge[v].push_back((struct node){v, u, w});
        }
        mp[1] = 0;//这里map的赋值一定要放在最后赋值，数据里貌似有给边界点赋值，但是最后边界点必须是这两个
        mp[n] = num+1;
        a[0] = 1;//刚开始命名客栈的时候并没有把1考虑在内
        a[num+1] = n;
        for(int i = 0; i <= num+1; i++)
            spfa(a[i]);
        floyd();
        if(G[0][num+1] != INF) printf("%d\n", G[0][num+1]-1);
        else printf("-1\n");
    }
    return 0;
}