傳送門

題意：在一個大樓裡，有編號為0~99的100層樓裡，還有n座電梯，任務是從0樓到達第k樓，每個電梯都有一個執行速度，表示到達一個相鄰樓層需要的時間，由於每個電梯不一定每層都停留，有時需要從一個電梯換到另一個電梯中。換電梯時間總是一分鐘，前提兩座電梯能停留在換乘樓層，大樓裡只有你一個人，問最少需要的時間？

題解：對於電梯x來說，假如它在第i層停留，把x在i層的出口看作一個頂點記為x*100+i。對於x的下一個停靠站j來說，x*100+i和x*100+j可以連一條邊，權值就是這個電梯從i到j層所需要的時間，而對於同樣在i層停靠的每個電梯來說，x*100+i到y*100+i也連一條邊，權值為60(同層換乘)。建圖後，遍歷所有的x*100的點u和y*100+k的v，使用dijkstra演算法求出所有的u，v最短距離的最小值即為所求結果。

附上程式碼：

#include<bits/stdc++.h>
#define _for(i,a,b) for( int i=(a); i<(b); ++i)
#define _rep(i,a,b) for( int i=(a); i<=(b); ++i)
using namespace std;
const int MAXN = 5, MAXK = 100, MAXP = MAXN*MAXK;
const int INF = 100000 + 10;

struct Edge{ int from, to, dist; };
struct HeapNode{
    int d, u;
    bool operator < (const HeapNode& rhs) const { return d > rhs.d; }
};
template<int MAXSIZE>
struct Dijkstra{
    int n, m, d[MAXSIZE], p[MAXSIZE];
    vector<Edge> edges;
    vector<int> G[MAXSIZE];
    bool done[MAXSIZE];

    void init(int n)
    {
        this->n = n;
        for(int i = 0; i < n; i++) G[i].clear();
        edges.clear();
        m = 0;
    }

    void addEdge(int from, int to, int dist)
    {
        edges.push_back((Edge){from, to, dist});
        m = edges.size();
        G[from].push_back(m - 1);
    }

    void dijkstra(int s)
    {
        priority_queue<HeapNode> Q;
        fill_n(d, n, INF);
        d[s] = 0;
        fill_n(done, n, false);
        Q.push((HeapNode){0, s});
        while(!Q.empty()) {
            HeapNode x = Q.top(); Q.pop();
            int u = x.u;
            if(done[u]) continue;
            done[u] = true;
            const vector<int>& adj = G[u];
            for(int i = 0; i < adj.size(); i++)
            {
                Edge& e = edges[adj[i]];
                int to = e.to;
                if(d[to] > d[u] + e.dist) {
                    d[to] = d[u] + e.dist;
                    p[to] = adj[i];
                    Q.push((HeapNode){d[to], to});
                }
            }
        }
    }
};

Dijkstra<MAXP+1> solver;
int n, k, T[MAXN];
vector<int> Level[MAXK];
char buf[512];
int readint() { int x; scanf("%d", &x); return x; }

int solve() {
    solver.init(n*MAXK+1);
    _for(i, 0, n) T[i] = readint();
    fgets(buf,500,stdin);
    _for(e, 0, n){
        fgets(buf,500,stdin);
        stringstream iss(buf);
        bool first = true;
        int l1, l; // 上一層，當前層
        while(iss>>l) {
            if(first) first = false;
            else {
                int v = MAXK*e + l1, v2= MAXK*e + l;
                int dist = (l-l1)*T[e];
                solver.addEdge(v,v2,dist);
                solver.addEdge(v2,v,dist);
                // printf("[%d,%d]-%d\n",v, v2, dist);
            }
            Level[l].push_back(e);
            l1 = l;
        }
    }

    _for(i, 0, MAXK) {
        vector<int>& li = Level[i];
        _for(j, 0, li.size()){
            _for(m, j+1, li.size()) {
                int e1 = li[j], e2 = li[m], v1 = e1*MAXK+i, v2 = e2*MAXK+i;
                solver.addEdge(v1,v2,60);
                solver.addEdge(v2,v1,60);
                // printf("[%d,%d]-%d\n",v1, v2, 60);
            }
        }
    }

    vector<int>& L0 = Level[0];
    vector<int>& Lk = Level[k];
    if(L0.empty() || Lk.empty()) return INF;

    int ans = INF;
    for(auto i : L0) {
        solver.dijkstra(i * 100);
        for(auto j : Lk) ans = min(ans, solver.d[j*100 + k]);
    }

    return ans;
}

int main(){
    while(scanf("%d %d\n", &n, &k) == 2) {
        int ans = solve();
        if(ans != INF) printf("%d\n", ans);
        else puts("IMPOSSIBLE");
    }
    return 0;
}