总结一下最小生成树与单源最短路的区别：

最小生成树：找最小的连通路径使每个节点都可以直接或者间接的连通起来。可以通过prime算法枚举各个点，并通过松弛操作（注意与dijkstra松弛时的区别，一个是到最小生成树的整体最短路，一个是到源点的最短路）实现。也可以用kruskal算法通过将边进行排序后从小到大枚举边实现，在从小到大枚举边时需要通过并查集判断边之间是否已经连接。

单源最短路：从某一个点出发，到其他任意一点的最短路径。可以通过dijsktral算法求但此算法的局限在于，它是利用贪心的思想无法处理存在负权的情况。而Bellman_ford算法可以处理负权的情况但对负权的环无能为力。不过可以判断是否存在负圈通过第n次松弛操作。

模板参考：https://blog.csdn.net/u013480600/article/details/44877465

简单模板理解实现的原理

//Bellman_Ford算法简单形式
//求的是从0点到其他点的单源最短路径,复杂度O(n*m)
 
#define INF 1e9
const int maxn=1000;
int n,m;//点数,边数，编号都从0开始
int w[maxn];//w[i]表示第i条边的权值(距离)
int u[maxn],v[maxn];//u[i]和v[i]分别表示第i条边的起点和终点
int d[maxn];//单源最短路径
 
//计算以s为源点的单源最短距离
void Bellman_Ford(int s)
{
    for(int i=0;i<n;i++) d[i]=INF;
    d[s]=0;
    for(int k=0;k<n-1;k++)  //迭代n-1次
    for(int i=0;i<m;i++)    //检查每条边
    {
        int x=u[i],y=v[i];
        if(d[x]<INF) d[y] =min(d[y],d[x]+w[i]); //松弛
    }
}

//Bellman_Ford标准版模板_SPFA(能判负圈)
//求的是从s点到其他点的单源最短路径,复杂度O(n*m)
 
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
#define INF 1e9
 
struct Edge
{
    int from,to,dist;
    Edge(int f,int t,int d):from(f),to(t),dist(d){}
};
 
struct BellmanFord
{
    int n,m;            //点数和边数,编号都从0开始
    vector<Edge> edges; //边列表
    vector<int> G[maxn];//每个节点出发的边编号(从0开始编号)
    bool inq[maxn];     //是否在队列中
    int d[maxn];        //s到各个点的距离
    int p[maxn];        //最短路中的上一条弧
    int cnt[maxn];      //进队次数
 
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }
 
    void AddEdge(int from,int to,int dist)
    {
        edges.push_back(Edge(from,to,dist));
        m = edges.size();
        G[from].push_back(m-1);
    }
 
    //计算以s为源点的最短路径
    //如果图中存在s能到达的负圈，那么返回true
    bool negativeCycle(int s)
    {
        queue<int> Q;
        memset(inq,0,sizeof(inq));
        memset(cnt,0,sizeof(cnt));
        for(int i=0;i<n;i++) d[i]= i==s?0:INF;
        Q.push(s);
 
        while(!Q.empty())
        {
            int u=Q.front(); Q.pop();
            inq[u]=false;
            for(int i=0;i<G[u].size();i++)
            {
                Edge &e=edges[G[u][i]];
                if(d[e.to] > d[u]+e.dist)
                {
                    d[e.to] = d[u]+e.dist;
                    p[e.to] = G[u][i];
                    if(!inq[e.to])
                    {
                        Q.push(e.to);
                        inq[e.to]=true;
                        if(++cnt[e.to]>n) return true;
                    }
                }
            }
        }
        return false;
    }
}BF;