算法训练-最短路

题目描述

给定一个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，保证从任意顶点都能到达其他所有顶点。

思路

对于这个存在负边的有向图而且结点比较大的用spfa算法，它在形式上与bfs是相似的，但是spfs中一个点进入的队列再从队列出来，后面可能会重新进入队列中
spf的算法思想：设立队列q用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
const int INF = 1e9;

struct Node{
    int  num;
    int load = INF;
};
vector < Node > v[20000+50];
int len[20050];
bool vis[20050];
void SPFA()
{
    queue < int > q;
    q.push(1);
    memset(vis,0,sizeof(vis));
    vis[1] = 1;
    while(!q.empty())
	{
        int now = q.front();
        q.pop();
        vis[now] = 0;
        for(int i = 0;i < v[now].size(); ++i)
		{
            int tmp = v[now][i].num;
            int link = v[now][i].load;
            if(len[tmp] > link + len[now]){
                len[tmp] = link + len[now];
                if(vis[tmp] == 0)
				{
                    q.push(tmp);
                    vis[tmp] = 1;
                }
            }
        }
    }
}
int main(){
    for(int i = 0;i < 20050; ++i)
        len[i] = INF;
    len[1] = 0;
    int n,m;
    cin >> n >> m;
    for(int i = 0;i < m; ++i)
	{
        int x,y,l;
        Node tmp;
        cin >> x >> y >> l;
        tmp.num = y;
        tmp.load = l;
        v[x].push_back(tmp);

    }
    SPFA();
    for(int i = 2; i <= n; ++i){
        cout << len[i] << endl;
    }
    return 0;
}