【区别】最短路&最小生成树

一句话概括：最小生成树是计算从一节点到另一节点的最小边集；最短路是带权路径，计算权值最小。也就是说，最小生成树要经过每一个点，而最短路只需要能达到某两点，路径权值最小即可！

两个算法具有相当大的相似性，而且都用到了贪心思想，所以把他们放到一起。

【最短路】常用的算法有dijkstra，bellman-ford，floyd，而【最小生成树】则是prim和kruskal。下面是各个算法的模板。
【Dijkstra复杂度O(n^2)】

#include<stdio.h>  //最短路  #define maxsum 0x3fffffff    int map[101][101],dist[101],s[101];    void Dijkstra(int n,int x)  //n,1,递推实现  {        int mindis,u,i,j;        for(i=1;i<=n;i++)        {            dist[i]=map[i][x];//map[x][i] is OK，dist表示i到原点的最小距离！          s[i]=0; //printf("%d/n",dist[i]);      }        s[x]=1;// x=1      for(i=1;i<=n;i++)        {            mindis=maxsum;            u=-1;           // 找出当前未使用的点j的dist[j]最小值          for(j=1;j<=n;j++)          if(s[j]==0 && dist[j]<mindis)//------------(2)          {                u=j;  //保存当前邻接点中最小的              mindis=dist[j];            }            s[u]=1;//u点已存入s集合，最小的！所以放外面           //更新dist          for(j=1;j<=n;j++)  //-------------------(3)            if(s[j]==0)                if( dist[u]+map[u][j]<dist[j] && map[u][j]<maxsum) //从u点发散出去寻找，map[u][j]<maxsum存在权值 ,map[j][u] is OK               dist[j]=dist[u]+map[u][j];        }    }    int main()    {        int n,m,a,b,c,i,j;        while(scanf("%d%d",&n,&m)!=EOF)        {            if(n==0&&m==0) break;            for(i=1;i<=n;i++)              for(j=1;j<=n;j++)              map[i][j]=maxsum;//初始化邻接矩阵          for(i=1;i<=m;i++)            {               scanf("%d%d%d",&a,&b,&c);                map[a][b]=map[b][a]=c;//构造邻接矩阵,对称的！无向！          }            Dijkstra(n,1);            printf("%d/n",dist[n]);      }        return 0;    }     

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
【最小生成树的prim模板：复杂度O(n^2)】

#include<iostream>//最小生成树#define INF 0x1f1f1f1f#define M 1000using namespace std;double dis[M],map[M][M];bool flag[M];int prim(int s,int n)                        //s为起点，n为点的个数{    int i,j,k,temp,md,total=0;    for(i=1;i<=n;i++)        dis[i]=map[s][i];                    //与最短路不同，而是将dis置为map[s][i]    memset(flag,false,sizeof(flag));    flag[s]=true;                            //将起点加入集合    for(i=1;i<n;i++){                        //依旧进行n-1次迭代，每次找到不在集合的最小边（n个点有n-1条边）！！！！！！        md=INF;    for(j=1;j<=n;j++){        if(!flag[j]&&dis[j]<md){            md=dis[j];            temp=j;        }    }    flag[temp]=true;                      //将找到的最小边的点加入集合    total+=md;                            //并将这个边的权值加到total中    for(j=1;j<=n;j++)                     //松弛操作，注意与最短路不同    if(!flag[j]&&dis[j]>map[temp][j])        dis[j]=map[temp][j];       }    return total;}

【Kruskal最小生成树模板  复杂度O(E*logE)】

typedef struct edge{    int a;    int b;    int value;}edge;edge edges[earraysize];int final[narraysize];            //存储父节点 中括号里面是儿子，外面是父亲int nodecount[narraysize];        //存储该节点孩子结点的个数 bool cmp(edge a,edge b){     return a.value<b.value;}int findp(int x)    //寻找父亲{    while(x!=fa[x])        x=fa[x];    return x;}bool Union(int x,int y)          //合并 {    int rootx=findp(x);          /*为什么要找父亲？因为要判是否有回路，假如父亲相同，而x跟y连通，那么就形成了回路*/    int rooty=findp(y);    if(rootx==rooty)        return false;    else if(nodecount[rootx]<=nodecount[rooty])      //优化，把深度小的子树加到深度大的子树，减少树的高度    {        final[rootx]=rooty;                         /*其实不优化也可以直接final[rootx]=rooty或者final[rooty]=rootx也ok */        nodecount[rooty]+=nodecount[rootx];    }    else    {        final[rooty]=rootx;        nodecount[rootx]+=nodecount[rooty];    }    return true;}int main (){    //freopen("a.txt","r",stdin);    int num=0;    int n,m;    int i,j;    while ( scanf ( "%d%d", &n, &m ) != EOF )    {        num=0;              //记录生成树中的边的数目        for(i=1;i<=m;i++)        {            scanf("%d%d%d",&edges[i].a,&edges[i].b,&edges[i].value);        }        for(i=1;i<=n;i++)      //初始化                        {            final[i]=i;            nodecount[i]=1;        }        sort(edges+1,edges+m+1,cmp);   //排序                                     for(i=1;i<=m;i++)              //遍历所有的边         {            if(Union(edges[i].a,edges[i].b))         //合并             {                num++;            }            if(num==n-1)               //找到了最小生成树                 break;        }    }    return 0;}

*****************************************************************************************************************************************************************************************

*****************************************************************************************************************************************************************************************
下面是最短路的bellmen-ford算法，与dijkstra不同，bellman-ford可以运用于有负权值的图，不过复杂度很高，O(VE )... 慎用~（可以用SPFA，它bwllman-ford的扩展）
Bellman-ford算法同样是对每条边进行N-1次松弛，当有权值为负时，对所有边进行N-1次松弛，如果dis还能更新，说明有负环。

ps：名词解释【负环】 在一个图里每条边都有一个权值（有正有负)
如果存在一个环（从某个点出发又回到自己的路径），而且这个环上所有权值之和是负数，那这就是一个负权环，也叫负权回路
存在负权回路的图是不能求两点间最短路的，因为只要在负权回路上不断兜圈子，所得的最短路长度可以任意小。

Bellman-ford原理：

1.如果最短路存在，则每个顶点最多经过一次，因此不超过n-1条边；

2.长度为k的路由长度为k-1的路加一条边得到；

3.由最优性原理，只需依次考虑长度为1，2，…，k-1的最短路。

Bellman-ford模板：

#include<stdio.h>//最短路#include<string.h>#define INF 0x1f1f1f1f#define MAX 102#define MAXM 20008int dist[MAX];struct Edge{                                                   //边结构体定义     int u, v, w;    Edge(){}    Edge(int a, int b, int c):u(a), v(b), w(c){}}edge[MAXM];int bellman_ford(int n, int m, int s)                           //n个点、m条边、s为起点 {    memset(dist, 0x1f, sizeof(dist));                          //初始化距离很大     dist[s] = 0;    int i, j, u, v, f;    for (i = 1; i < n; ++i)                                   //迭代 n - 1 次，对每条边进行n-1次松弛    {        f = 0;        for (j = 0; j < m; ++j)        {            u = edge[j].u;            v = edge[j].v;            if (dist[v] > dist[u] + edge[j].w)               // 松弛操作             {                dist[v] = dist[u] + edge[j].w;                f = 1;                }         }         if (!f) return 1;                                     //如果其中一次迭代没改变，停止     }     for(j = 0; j < m; ++j)                                   //再进行一次迭代      {         u = edge[j].u;         v = edge[j].v;         if (dist[v] > dist[u] + edge[j].w)                   //若还能松弛, 则存在负环          return -1;                                        //存在负环返回 -1      }   return 1;                                           //没有负环返回 1 }

算法结束后dist数组已经是最短路径。

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

【SPFA模板： 期望的时间复杂度O(KE)， 其中K为所有顶点进队的平均次数，可以证明K一般小于等于2。】

#include<iostream>//最短路  #include<string.h>  #include<cstdio>  #include <vector>  #include <queue>  using namespace std;  #define N 50001int   INF = 0x7fffffff;  int n,m;  typedef struct edge  {         int to;         int w;  }edge,temp;  vector<edge> adjmap[N]; //vector实现邻接表  int d[N];  bool vis[N];          //记录顶点是否在队列中，SPFA算法可以入队列多次  int cnt[N];             //记录顶点入队列次数  void SPFA()  {           queue<int>       myqueue;           int i;           for(i=1;i<=n;++i)                      d[i] = INF;        //将除源点以外的其余点的距离设置为无穷大           memset(vis,0,sizeof(vis));           memset(cnt,0,sizeof(cnt));           d[1]=0;              //源点的距离为0           vis[1] = true;           cnt[1]++;            //源点的入队列次数增加           myqueue.push(1);           int topint;           while(!myqueue.empty())           {                   topint = myqueue.front();                   myqueue.pop();                   vis[topint] = false;                   for(i=0;i<adjmap[topint].size();++i)                   {                           int to = adjmap[topint][i].to;                           if(d[topint]<INF && d[to]>d[topint]+ adjmap[topint][i].w)                           {                                    d[to] = d[topint]+ adjmap[topint][i].w;                                    if(!vis[to])                                    {                                            vis[to] = true;                                            cnt[to]++;                                            if(cnt[to]>=n)   //当一个点入队的次数>=n时就证明出现了负环。                                              return ;                                            myqueue.push(to);                                    }                       }                }                     } printf("%d/n",d[n]);    }  int main()  {          //freopen("a.txt","r",stdin);          scanf("%d%d",&n,&m);          int i;          int s,e,w;          edge temp;          for(i=1;i<n+1;++i)       //此处特别注意对邻接表清空              adjmap[i].clear();          for(i=0;i<m;++i)         //双向          {                  cin>>s>>e>>w;                  temp.to = e;                  temp.w = w;                  adjmap[s].push_back(temp);                  temp.to = s;                  adjmap[e].push_back(temp);          }           SPFA();           return 0;  }