最小生成树&最短路基础算法总结

【最短路问题】

解决最短路问题有以下算法：Dijkstra算法，Bellman-Ford算法，Floyd算法，和SPFA算法和启发式搜索算法A*;

每个算法都有它的特点可以解决某些特定的问题，例如：Floyd算法可以求解任意两点之间的最短路径长度，SPFA可以判定是否存在负环问题

一. Dijkstra 算法：

　　解决的问题：<非负权图单源最短路>1.从某一点出发到所有点的最短路径，就是最后更新的dis数组2.从某一个点到出发到具体某一点的最短路，只要第一次吧这个点加入最短路就可以终止程序了。3.注意Dijkstar 算法不能处理负权边

　　思想：贪心

　　做法: 每次将未加入最短路径的点种找距离出发点最近的点加入，然后用这个点更新所有没有加入的点到起始点的最小距离，每次加入一个点更新一次，直到所有的点都加入数组后结束，就可以统计出这个点到所有点的最短路径了

　　算法复杂度：斐波那契堆的复杂度O(E+VlgV)

　　核心代码：

void dijk(int s , int n)
{
    int i , j , k ;
    for( i = 1 ; i <= n ;i++)
    {
        p[i] = false;
        dist[i] = mp[s][i];
    }
    p[s] = true;
    dist[s] = 0;
    for(i = 1 ; i < n ; i++)
    {
        int Min = INF;
        int k = 0 ;
        for( j = 1 ; j <= n ;j++)
        {
            if(!p[j]&&dist[j]<Min)
            {
                Min = dist[j];
                k = j;
            }
        }
        if(Min==INF) return ;
        p[k] = true;
        for(j = 1 ; j <= n ;j++)
        {
            if(!p[j]&&mp[k][j]!=INF&&dist[j]>dist[k]+mp[k][j])
                dist[j] = dist[k]+mp[k][j];
        }
    }
}

 

二.BellmanFord 算法和SPFA 算法（Shortest Path Faster Algorithm）

　　解决的问题：1.权值有负值得图的单源最短路，并且可以检测到负环，注意，由于B_F算法的复杂度过高而且都可以用SPFA解决，所以我们只学习SPFA算法（一个特例：bellman可以检测并输出负环，单SPFA不能输出负环）2.最长路

　　思想：松弛操作

　　做法：设置一个队列，开始将初始点加入这个队列中，如果队列不空的话，取出队列顶端的元素i，用队列顶端的元素对所有的点j进行松弛操作　　if(mp[i][j]!=INF&&dis[j]>dis[i]+mp[i][j]) dis[j] = dis[i]+mp[i][j];　　如果j点没有在队列中，说明它还有更新其他点的潜力，所以将被更新的j点也加入到队列中去，设置一个计数器，设总点数为n，如果一个点进队的次数大于n则说明存在负环。

　　算法复杂度：O(kE) k是每个节点进队的次数，一般来说k<=2;但是这里的复杂度证明是有问题的，所以SPFA的最坏的情况应该是O(VE)

　　核心代码:

1、初始化所有点，每一个点保存一个值，表示从源点到达这个点的距离，将源点的值设为0，其他点的值设为无穷大（表示不可达）
2、进行循环，循环n-1次。在循环内部，遍历所有的边，进行松弛计算
3、遍历图中所有的边，判断是否存在这样情况d[v]>d[u]+w(u,v); 
，则表示图中存在从源点可达的负权回路

int SPFA()
{
    memset(inq,0,sizeof(inq));
    for(int i =0 ;i <= n ;i++)
        dis[i] = INF;
    top = 0;
    dis[1] = 0;
    que[top++] = 1;
    inq[1]=true;
    for(int i = 0;i != top ;i = i+1%N)//队列不为空，注意i和top不是同时循环到下一次的
    {
        int u = que[i];
        inq[u]=false;
        for(int j = head[u] ; j!=-1 ;j = edge[j].next)
        {
            Edge e = edge[j];
            if(dis[e.to]>dis[u]+e.w)
            {
                dis[e.to] = dis[u]+e.w;
                if(inq[e.to]==false)
                {
                    que[top++] = e.to;
                    top %= N;//循环队列
                    inq[e.to] = true;
                }
            }
        }
    }
    return dis[n];
}

　三.Floyd 算法：

　　解决的问题：1.全局最短路。2.最长路

　　思想：动态规划

　　做法：对于每个节点k，都对定点对[i,j]做一次松弛操作

　　算法复杂度：O(n^3)

　　核心算法：

for (int k=0; k<n; ++k) {
  for (int i=0; i<n; ++i) {
    for (int j=0; j<n; ++j) {
            /*
            实际中为防止溢出，往往需要选判断 dist[i][k]和dist[k][j
            都不是Inf ，只要一个是Inf，那么就肯定不必更新。 
            */
      if (dist[i][k] + dist[k][j] < dist[i][j] ) {
        dist[i][j] = dist[i][k] + dist[k][j];
      }
    }
  }
}

　　说明：最短路的最优子结构（不只是对于Floyd，对于任何的最短路算法都有次性质）可以通过反证法证明，这里应用这个最优子结构的性质，来用Floyd算法来记录最短路的路径

void floyd() {
      for(int i=1; i<=n ; i++){
        for(int j=1; j<= n; j++){
          if(map[i][j]==Inf){
               path[i][j] = -1;//表示  i -> j 不通 
          }else{
               path[i][j] = i;// 表示 i -> j 前驱为 i
          }
        }
      }
      for(int k=1; k<=n; k++) {
        for(int i=1; i<=n; i++) {
          for(int j=1; j<=n; j++) {
            if(!(dist[i][k]==Inf||dist[k][j]==Inf)&&dist[i][j] > dist[i][k] + dist[k][j]) {
              dist[i][j] = dist[i][k] + dist[k][j];
              path[i][k] = i;
              path[i][j] = path[k][j];
            }
          }
        }
      }
    }
    void printPath(int from, int to) {
        /*
         * 这是倒序输出，若想正序可放入栈中，然后输出。
         * 
         * 这样的输出为什么正确呢？个人认为用到了最优子结构性质，
         * 即最短路径的子路径仍然是最短路径
         */
        while(path[from][to]!=from) {
            System.out.print(path[from][to] +"");
            to = path[from][to];
        }
    }

当然，这里只是提供一个思路，其实对于所有的最短路保存路径都可以用类似是dfs保存路径的方法，通过保存前驱的方法，每次松弛操作的时候对前驱也进行修改就可以了

　【最小生成树问题】

解决最小生成树问题的算法有：prim算法和kruskal算法

一.prim 算法(普利姆算法)

　　思想：贪心

　　做法：类似于dijkstra算法，只不过是每次选取的点是距离生成树最近的点，更新的时候不再是更新这个点到起始点的最短距离，而是到这个生成输的最短距离。

　　核心代码：

void prim(int s , int n)
{
    int i , j , k ;
    for( i = 1 ; i <= n ;i++)
    {
        p[i] = false;
        dist[i] = mp[s][i];
    }
    p[s] = true;
    dist[s] = 0;
    for(i = 1 ; i < n ; i++)
    {
        int Min = INF;
        int k = 0 ;
        for( j = 1 ; j <= n ;j++)
        {
            if(!p[j]&&dist[j]<Min)
            {
                Min = dist[j];
                k = j;
            }
        }
        if(Min==INF) return ;
        p[k] = true;
        for(j = 1 ; j <= n ;j++)
        {
            if(!p[j]&&mp[k][j]!=INF&&dist[j]>mp[k][j])
                dist[j] = mp[k][j];
        }
    }
}

　　时间复杂度：邻接矩阵：O(v^2) 　　　　邻接表：O(elog₂v)

二.kruskal 算法

　　思想:并查集

　　做法：将原图G中所有E条边按权值从小到大排序。循环：从权值最小的边开始遍历每条边，直至图G_new中所有的节点都在同一个连通分量中。每次从图中未加入树种的边种找到边权最小的看，这两个点的祖先是否是一个，如果是一个说明两个点已经是一个树上的了，不做操作，如果两个点来自不同的树即有不同的祖先，那么就把这两个点所代表的两个树合并起来，最后当所有的点都在一棵树上的时候停止操作，一般用合并次数来控制，即n个点需要合并n-1次，所以最好合并操作写在kruskal函数内部，这样方便统计步数

　　核心代码：

struct Edge{
    int from;
    int to;
    int w;
    bool operator < (const Edge &a) const
    {
        return w<a.w;
    }
}edge[N*N];
int fa[N];
int Getfa(int x){return (fa[x]==x)?x:fa[x] = Getfa(fa[x]); }
int fl;
int n,m;
bool solve(int x){
    int cnt = 0;//共合n-1次结束
    for(int i = 1; i <= n; i++) fa[i] = i;//注意点是从1开始编号的
    for(int i = x; i < m; i++){
        int X = Getfa(edge[i].from);
        int Y = Getfa(edge[i].to);
        if(X != Y){
            fa[X] = Y;
            cnt++;
            if(cnt==n-1){ fl = edge[i].w;return true;}
        }
    }
    return false;
}

注意：对于图的题，一定要根据题意来选取是用链表存储还是用数组存储，选择好的存储方法便于解决问题，也要注意点的编号是从几开始的。