uva 10801 - Lift Hopping

裸最短路算法

一开始因为k=0的情况应该输出0而错了几遍、

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <vector>
using namespace std;
const int maxn = 100+5;
const int INF = ~0U >> 1;
struct node {
    int from, to, val;
    node(int a, int b, int c) : from(a), to(b), val(c) { }
};
struct pii {
    int d, u;
    pii(int a, int b) : d(a), u(b) { }
    bool operator < (const pii& rhs) const {
        return d > rhs.d;
    }
};
vector<node> edge;
vector<int> G[maxn];
int d[maxn];
int vis[maxn];
int n, k;
int deep[10];

void init() {
    for(int i = 0; i < 100; ++i) G[i].clear();
    edge.clear();
    memset(vis, 0, sizeof(vis));
    memset(d, 0, sizeof(d));
    memset(deep, 0, sizeof(deep));
    return ;
}

void addedge(int from, int to, int val) {
    edge.push_back(node(from, to, val));
    edge.push_back(node(to, from, val));
    int t = edge.size();
    G[from].push_back(t-2);
    G[to].push_back(t-1);
    return ;
}

void dis(int s) {
    priority_queue<pii> que;
    for(int i = 0; i < maxn; ++i) d[i] = INF;
    d[s] = 0;
    memset(vis, 0, sizeof(vis));
    que.push(pii(0, s));
    while(!que.empty()) {
        pii t = que.top();
        que.pop();
        int u = t.u;
        if(vis[u]) continue;
        vis[u] = 1;
        for(int i = 0; i < G[u].size(); ++i) {
            node& e = edge[G[u][i]];
            if(d[e.to] > d[u] + e.val) {
                d[e.to] = d[u] + e.val;
                que.push(pii(d[e.to], e.to));
            }
        }
    }
    return ;
}

int main() {
    while(scanf("%d%d", &n, &k) != EOF) {
        init();
        for(int i = 0; i < n; ++i)
            scanf("%d", &deep[i]);
        getchar();

        for(int j = 0; j < n; ++j) {
            int t;
            char c;
            char s[5] = {0};
            int ka = 0;
            int str[maxn], cnt = 0;
            while((c = getchar()) != '\n') {
                if(c != ' ') s[ka++] = c;
                else {
                    str[cnt++] = atoi(s);
                    memset(s, 0, sizeof(s));
                    ka = 0;
                }
            }
            str[cnt++] = atoi(s);

            for(int i = 0; i < cnt; ++i) {
                for(int v = i + 1; v < cnt; ++v) {
                    int t = (str[v] - str[i]) * deep[j];
                    addedge(str[i], str[v], t+60);
                }
            }
        }
        dis(0);
        if(k == 0) printf("0\n");
        else if(d[k] == INF) printf("IMPOSSIBLE\n");
        else printf("%d\n", d[k]-60);
    }
    return 0;
}