UVa 10801

　　题目大意：一座楼有100层，编号0-99，有n个电梯，每个电梯有不同的速度，并且只在指定的楼层停，在某一层如果有多个电梯停，在两个电梯间转移需要1分钟，求出从0层出发到达k层的所用的最短时间。

　　本来是正常的单源最短路问题，可是电梯转移花费的时间使得问题复杂了。刚开始是把一个节点扩展成两个节点，一个进一个出，在进出两个节点间加上60s的开销，纠结的好久才憋出来（犯了好多错误...浪费了好长时间），结果却WA了，用别人的测试用例结果也对，忽然就想到可能最终要到0层（写代码时考虑到了，可是认为不会这么干，也就没多写），处理完0之后，就好了...-_-||

#include <cstdio>
#include <vector>
#include <cstring>
#include <cctype>
using namespace std;
#define MAXN 210
#define INF 1e8

int G[MAXN][MAXN], dist[MAXN];
bool vis[MAXN];

int main()
{
#ifdef LOCAL
    freopen("in", "r", stdin);
#endif
    int n, k;
    int time[10];
    while (scanf("%d%d", &n, &k) != EOF)
    {
        for (int i = 0; i < n; i++)
            scanf("%d", &time[i]);
        getchar();
        for (int i = 0; i < 200; i++)
            for (int j = 0; j < 200; j++)
                G[i][j] = INF;
        for (int i = 0; i < 100; i++)
            G[i*2][i*2+1] = G[i*2+1][i*2] = 60;
        for (int i = 0; i < n; i++)
        {
            char str[10000];
            gets(str);
            vector<int> v;
            int len = strlen(str);
            for (int j = 0; j < len; j++)
            {
                if (isdigit(str[j]))
                {
                    int t = str[j] - '0';
                    j++;
                    while (j < len && isdigit(str[j]))
                    {
                        t = t * 10 + str[j] - '0';
                        j++;
                    }
                    v.push_back(t);
                }
            }
            for (int j = 0; j < v.size(); j++)
                for (int p = j+1; p < v.size(); p++)
                {
                    int x = v[j], y = v[p];
                    G[2*x+1][2*y] = G[2*y+1][2*x] = min(G[2*x+1][2*y], (y-x)*time[i]);
                }
        }
        memset(vis, 0, sizeof vis);
        for (int i = 0; i < 200; i++)
            dist[i] = INF;
        dist[1] = 0;
        if (k)  k *= 2;
        else  k = 1;
        for (int i = 0; i < 200; i++)
        {
            int u, lmin = INF;
            for (int j = 0; j < 200; j++)
                if (!vis[j] && dist[j] <= lmin)
                {
                    lmin = dist[j];
                    u = j;
                }
            vis[u] = 1;
            if (u == k)  break;
            for (int j = 0; j < 200; j++)
                dist[j] = min(dist[j], dist[u]+G[u][j]);
        }
        if (dist[k] != INF)  printf("%d
", dist[k]);
        else  printf("IMPOSSIBLE
");
    }
    return 0;
}

　　后来看到可以不用这么麻烦，也是，上面那个代码构图时考虑了几次才对了。正常构图，在算权重的时候加上60就可以了（从0扩展出来的不用加60）。

#include <cstdio>
#include <vector>
#include <queue>
using namespace std;
#define MAXN 110
#define INF 1e9
#define N 100
typedef pair<int, int> ii;
typedef vector<ii> vii;

int G[MAXN][MAXN];
int time[10];

int main()
{
#ifdef LOCAL
    freopen("in", "r", stdin);
#endif
    int n, k;
    while (scanf("%d%d", &n, &k) != EOF)
    {
        for (int i = 0; i < n; i++)
            scanf("%d", &time[i]);
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
                G[i][j] = INF;
        for (int i = 0; i < n; i++)
        {
            vector<int> v;
            do
            {
                int x;
                scanf("%d", &x);
                v.push_back(x);
            } while (getchar() != '
');
            for (int p = 0; p < v.size(); p++)
                for (int q = p+1; q < v.size(); q++)
                {
                    int x = v[p], y = v[q];
                    G[x][y] = G[y][x] = min(G[x][y], (y-x)*time[i]);
                }
        }
        vector<int> dist(N, INF);
        dist[0] = 0;
        priority_queue<vii, vector<ii>, greater<ii> > pq;
        pq.push(ii(0, 0));
        while (!pq.empty())
        {
            ii top = pq.top();
            pq.pop();
            int d = top.first, u = top.second;
            if (u == k)  break;
            if (d == dist[u])
                for (int v = 0; v < N; v++)
                {
                    if (u == 0)
                    {
                        if (dist[u] + G[u][v] < dist[v])
                        {
                            dist[v] = dist[u] + G[u][v];
                            pq.push(ii(dist[v], v));
                        }
                    }
                    else
                    {
                        if (dist[u] + G[u][v] + 60 < dist[v])
                        {
                            dist[v] = dist[u] + G[u][v] + 60;
                            pq.push(ii(dist[v], v));
                        }
                    }
                }
        }
        if (dist[k] != INF) printf("%d
", dist[k]);
        else  printf("IMPOSSIBLE
");
    }
    return 0;
}