ALGO-5 算法训练 最短路

题目:

时间限制：1.0s   内存限制：256.0MB


问题描述

给定一个n个顶点，m条边的有向图（其中某些边权可能为负，但保证没有负环）。请你计算从1号点到其他点的最短路（顶点从1到n编号）。
输入格式

第一行两个整数n, m。

接下来的m行，每行有三个整数u, v, l，表示u到v有一条长度为l的边。
输出格式
共n-1行，第i行表示1号点到i+1号点的最短路。
样例输入
3 3
1 2 -1
2 3 -1
3 1 2
样例输出
-1
-2
数据规模与约定

对于10%的数据，n = 2，m = 2。

对于30%的数据，n <= 5，m <= 10。

对于100%的数据，1 <= n <= 20000，1 <= m <= 200000，-10000 <= l <= 10000，保证从任意顶点都能到达其他所有顶点。

分析:

        题意很明确, 关键是边权可以是负数, 因此使用Bellman-Ford 算法, 需要使用Queue优化, 要不然会超时。

代码:

#include <bits/stdc++.h>
#define N 20001
#define M 200001
using namespace std;
struct Edge{
    int from, to, dist;
}edges[M];
int m = 0;
vector<int> head[N];    // 邻接表头
int d[N];               // 经过k轮松弛得到最短路
bool inq[N];            // 表示已经在队列当中
void addEdge(int from, int to, int dist) {
    edges[m].from = from, edges[m].to = to, edges[m].dist = dist;
    head[from].push_back(m++);
}

int bellmanFord(int s, int n, int m) {
    queue<int>  Q;
    memset(inq, 0, sizeof(inq));
    for(int i = 1; i <= n; ++i) d[i] = INT_MAX;
    d[s] = 0;
    inq[s] = true;
    Q.push(s);
    
    while(!Q.empty()) {
        int u = Q.front(); Q.pop();
        inq[u] = false;
        for(int i = 0; i < head[u].size(); ++i) {       // 循环当前顶点链接的边
            Edge& e = edges[head[u][i]];
            if(d[u] < INT_MAX && d[e.to] > d[u] + e.dist) {
                d[e.to] = d[u] + e.dist;
                if(!inq[e.to]) Q.push(e.to);
            }
        }
    }
}

int main()
{
#ifdef LOCAL
    freopen("ALGO-5.in", "r", stdin);
#endif
    std::ios::sync_with_stdio(false);
    int n, m, u, v, w;
    cin >> n >> m;
    for(int i = 0; i != m; ++i)
        cin >> u >> v >> w, addEdge(u, v, w);
        
    bellmanFord(1, n, m);
    for(int i = 2; i <= n; ++i)
        cout << d[i] << endl;
    return 0;
}