poj 2387

题目概述

城市中有N个地点，编号1到N，城市中有T条双向路，经过每条路都需要一定时间，某人在N点，要到1点，问最快多久能到

时限

1000ms/3000ms

输入

第一行正整数T,N，其后T行，每行三个正整数，路连接的两个点，途径用时，输入只有一组

限制

2<=N<=1000;1<=T<=2000;1<=用时<=100

输出

一个数，最短用时

样例输入

5 5
1 2 20
2 3 30
3 4 20
4 5 20
1 5 100

样例输出

90

讨论

图论，单源最短路，bellman_ford队列优化算法，非常直白的描述，由于是双向路，即便读错题也无所谓
同样由于题目略水，只用了动态邻接表

题解状态

280K，32MS，C++，1094B

题解代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define INF 0x3f3f3f3f
#define MAXN 1003
#define memset0(a) memset(a,0,sizeof(a))

struct Edge//边的结构
{
    int to, w;//边的终点 边权重 这里是用时
    Edge() {}
    Edge(int to, int w) :to(to), w(w) {}
};
int T, N;//路总数 地点总数
vector<vector<Edge>>graph;//邻接表原始结构
queue<int>q;//辅助队列
int dis[MAXN];//distance 最短路长度
bool inq[MAXN];//辅助数组 在队列中
int fun()
{
    graph.resize(N + 1);
    for (int p = 0; p < T; p++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);//input
        graph[a].push_back(Edge(b, w));
        graph[b].push_back(Edge(a, w));
    }
    for (int p = 1; p <= N; p++)
        dis[p] = INF;
    dis[N] = 0;
    q.push(N);
    inq[N] = 1;
    while (!q.empty()) {
        int a = q.front();
        q.pop();
        inq[a] = 0;
        for (int p = 0; p < graph[a].size(); p++) {
            Edge b = graph[a][p];
            if (dis[b.to] > dis[a] + b.w) {
                dis[b.to] = dis[a] + b.w;
                if (!inq[b.to]) {
                    q.push(b.to);
                    inq[b.to] = 1;
                }
            }
        }
    }
    return dis[1];
}
int main(void)
{
    //freopen("vs_cin.txt", "r", stdin);
    //freopen("vs_cout.txt", "w", stdout);

    while (~scanf("%d%d", &T, &N)) {//input//只是保险而已 实际上只有一组
        printf("%d\n", fun());//output
        graph.clear();
    }
}

EOF