最短路径、最小生成树

简介

最短路径，的两种常用算法，Dijkstra 和 Floyd.（原题目）

Dijkstra适用于单源最短路径，即从某个点出发到其他各点的最短路径

Floyd适用于多源最短路径，即任意点到其他点的最短路径

还有一种SPFA，最短路径快速算法，基于深搜或广搜

 

最小生成树，即怎么最少的权重使所有点连通（原题目）

两种最常用的算法 kruskal 和 Prime。

Kruskal适用于稀疏图（边少）

Prim适用于稠密图（边多）

 

算法思路与实现

 

首先需要提一点，图有两种存储方式，一种邻接列表，第二次邻接矩阵

邻接链表一般先定义一个结构体，再结合vector实现

struct Edge{
    int g,w;//所连接的边以及权值
};
vector  G[200010];//邻接链表

    for(i=1;i<=m;i++) //邻接链表输入
    {
        cin>>f>>g>>w;  //f:起点、g:终点 w:权值
        tmp.g=g;tmp.w=w;
        G[f].push_back(tmp);
    }

邻接矩阵就是一个二维数组

 

最短路径

一、SPFA

SPFA有两种深搜和广搜实现方式，该算法可以处理负权值的情况。

基本思路

先自己想想，给我一张图，给一个起点，求该点到其他点的最短路径。正常的思路就是搜索，用回溯法标记，同时把每个点的最短距离存下来，深搜广搜都可以实现。

SPFA基本上也就是个这样的思想。

void bfs(int s)//SPFA 广搜版
{
    int i;
    queue q;
    q.push(s);
    vis[s]=1;//标记数组

    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        for(i=0;idis[t]+v)
            {
                dis[u] = dis[t]+v;//最短距离数组
                if(!vis[u])
                {
                    vis[u] =1;
                    q.push(u);
                }
            }
        }
        vis[t]=0;
    }
}

二、Dijkstra

Dijkstra是一种基于贪心的算法，不能处理权值为负的问题。起点出发，用一个数组存起点到各个点的最短距离。计算出当前点i到每个与其相连的点j,k,l...的距离，如果比其他点更近就跟新。然后在距离数组中找出与起点距离最小的且没有走过的点做为下个节点。

浅谈Dijkstra 这篇文章有详细的过程讲解与优化。

无优化版

void Dijkstra(int s,int n)//无优化版
{
    int i,j;
    dis[s]=0;
    for(i=1;i<=n;i++)
    {
        int Min = inf;
        for(j=1;j<=n;j++)//所有点中找出最小距离的且没走过的点
        {
            if(!vis[j]&&(inf==Min||dis[j]dis[Min]+v)
                dis[u]=dis[Min] + v;
        }
    }
}

优先队列优化版

#define M(x,y) make_pair(x,y)
priority_queue< pair > q;
void Dijkstra_proirity_queue(int s,int n)//优先队列优化版
{
    int j;
    q.push(M(0,s));
    while(!q.empty())
    {
        int Min = q.top().second;
        q.pop();
        if(vis[Min]) continue;//这一行优化很重要
        vis[Min]=1;
        for(j=0;jdis[Min]+v)
            {
                dis[u]=dis[Min] + v;
                q.push(M(-dis[u],u));
            }
        }
    }
}

三、Floyd

Floyd算法用来求多源最短路径，是一种基于动态规划的思想。

基本思路

从点i到点j,可以直接从i-->j，也可以经过其他路径间接过来i-->k-->j，取直接和间接中更优的那种情况。

数组DP[i][j]表示从i-->j的最短距离

状态转移： DP[i][j] = min(DP[i][j],DP[i][k]+DP[k][j]);

初始化：DP每个位置为无穷大

void floyd(int n)
{
    int i,j,k;
    for(k=1;k<=n;k++)
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
}

 

四、时间复杂度分析

SPFA：O（KE）  K：入队的次数 ，最坏O（nm）

Dijkstra无优化版：O（n*(n+m)） =  O(nm)

Dijkstra优化版： O((n+m)log(m+n) +m) ,据说堆优化能nlogn+m

Floyd: O(n^3)           n:顶点数 ，m:边数

 

最小生成树

一、Kruskal

思路：先将图看成单个单个的顶点，把边按照权值进行排序，用贪心的思想优先选取权值较小的边，并依次连接，若出现环则跳过此边（用并查集来判断是否存在环）继续搜保证不出现环路的情况下，当连接到n-1条边时，n个顶点全部连接完成。

图片来源：百度

并查集：可以理解为判断两个节点是否有共同的祖先。

了解并查集点击这里

Kruskal实现

int Find(int x)//并查集中找公共祖先
{
    while(x!=f[x])  x=f[x]=f[f[x]];
    return x;
}

bool cmp(node a,node b)//排序比较函数
{
    return a.z

 

二、Prim

思路：以任意边为起点，每次选择已经连通的点到未连通的点的所有边中最小权值的那条边。

图片来源：https://jingyan.baidu.com/album/9113f81b6707c52b3214c794.html?picindex=10

Prim思路和Dijkstra极其相似，实现步骤也基本相同。一点区别在于Prim的dis数组存的是所有边中，能到该顶点的最小边的权值，Dijkstra中dis存的是起点到该顶点的最小距离。

实现步骤：

0.初始化点为起点，用该点连接的所有边更新Dis数组，并将该点加入最小生成树book数组。

1.在Dis数组中找出最小的且不在生成树中的边所在的位置pos

2.枚举pos点的所有边，更新dis数组

3.重复1和2,直到有n个点已经连接（n-1条边）

代码：（Prim建议用邻接矩阵）

邻接矩阵版

int Prim(int n,int m,int *G[])//邻接矩阵版
{
    int pos;
    int i,j,k;
    for(int i=1;i<=n;i++)//去环操作
        G[i][i]=0;
    for(int i=1;i<=n;i++)//0.初始化dis
        dis[i]=G[1][i];
    book[1]=true;
    int sum=0;

    for(k=1;k<=n-1;k++)//n个点连通，只需n-1条边
    {
        int Min=INF;
        for(int i=1;i<=n;i++)//1.dis中找到最小的且不在生成树中的边
            if(book[i]==false && dis[i]G[pos][j])
                dis[j]=G[pos][j];
        }
    }
    return sum;
}

邻接链表版：

vector a[5005]; //邻接链表，prim建议用邻接矩阵
bool book[5005];    //记录该点是否被访问（是否已经在最小生成树中）
int dis[5005];  //存放到达每个点的最小边
int Prim(int n,int m)//每次连接能连接（已经连接的点中未使用的）的最小边,n:顶点数,m：边数
{
    int i;
    for(i=1;i<=m;i++)//转邻接链表
    {
        x.b=e[i].y;x.w=e[i].z;
        a[e[i].x].push_back(x);
    }

    for(i=1;i<=n;i++)//初始化
    {
        book[i]=false;
        dis[i]=inf;
    }

    book[1]=true;//从第一个点开始
    int pos = 1;
    for(i=0;ia[pos][j].w )
                dis[a[pos][j].b] = a[pos][j].w;
        }
    }
    return ans;

}

输入：n，m   ，m条边（起点，终点，权值）   

输出：最小生成树权值

 

这时候很容易想到一个问题。

既然Dijkstra可以优化，那么Prim可以优化吗？

答案是肯定的。

回想一下上面的代码，每次去dis数组里面查询最小的权值的时候都是从头到位遍历数组。相当于需要遍历n次，每次却只需要找一个最小的值。

这时候认真看过Dijkstra优化的小伙伴应该想到了，那我可以直接对数组进行一个类似于排序的操作，每次直接就可以得到最小值了。

那么优化查询常用的方法上场了。优先队列、堆、树状数组、线段树。。

思路：（完全同Dijkstra）

用一个优先队列，维护Dis数组（相当于复制了一个dis数组），同时维护顶点编号和权值，队顶即为最小值，每次只需要取队顶元素。

邻接链表版：

#define M(x,y) make_pair(x,y)
priority_queue< pair > q;
int Prim_proirity_queue(int n,int m)//优先队列优化版
{
    int i,j;
    int num=0;
    int sum =0;
    q.push(M(0,1));//第一个点放进去，权重赋0
    dis[1]=0;

    while(!q.empty())//Prim从这里开始
    {
        int Min_pos = q.top().second;
        q.pop();
        book[Min_pos]=1;
        sum+=dis[Min_pos];
        for(j=0;jv)
            {
                dis[u]=v;
                q.push(M(-dis[u],u));
            }
        }
        num++;
        if(num>=n) return sum;
    }
    if(num < n) return -1;
}

邻接矩阵写也是没问题的。

如果是需要A最上面那两个题目的，这里不给完整代码。

注意如果用Prim,输入需要处理自环（自己指向自己）、重边（多条a->b的边）。（测试数据真的有毒。）

5 18
2 4 276
3 3 435
3 4 608
2 4 860
1 2 318
1 3 547
5 4 419
2 5 98
1 5 460
5 3 399
3 5 240
3 2 733
3 3 903
4 2 909
5 2 206
3 4 810
2 1 115
2 3 419
sum:729

 

 

到这里差不多就结束了。

可能很多没有讲清楚的地方。那也没问题，只要自己动手实现一遍基本上就能理解了。