Dijkstra算法

朴素Dijkstra(一个顶点到其余各个顶点的最短路径算法,解决的是有权图中最短路径问题)

迪杰斯特拉算法主要特点是从起始点开始,采用贪心算法,每次遍历到起始点距离最近且未访问过的顶点的邻接节点,知道扩展到终点为止.

注意: 不能求负权图.

基本步骤:
1.初始化距离 dis[1]=0 一号点到起点的距离,其他点为正无穷.
2.for循环 0-n ,s:当前已经确定最短距离的点
找到不在s中的距离最近的点 赋值给t
t加入s中
t来更新其他点的距离,从t出去的所有边
通过for循环来确定每个点到起点的最短距离

边数多(稠密图)的话就用零阶矩阵来存储 --稠密图定义在于n^2~m点数的平方等于m

稀疏图用邻接表来存储.

通俗来理解:

我们先定义一个数组 S 来存放最短距离的点.//也可以用一个布尔数组来表示每个点是否加入最短数组中.

找到没有放入最短数组S中距离源点距离最短的点,然后再扩展该点的距离,这样就会将这个点扩展的边到源点的距离算出来,这样循环n-1(n-1此是因为总共n个点,但是最后一个点没有出度),这样就可以求出每个点到源点的最短距离.

模板:

int g[N][N];//表示边的权重
int dis[N];//表示每个点到源点的最短距离
bool str[N];//表示每个点是否放入最短数组S中
int n, m;//n个点,m条边

int Dijkstra()
{
    memset(dis, 0x3f, sizeof dis);//初始化dis数组,每个距离都为无穷大
    dis[1] = 0;//第一个点为源点,距离为0
    for(int i = 0;i < n-1;i++)
    {
        int t = -1;
        for(int j = 1;j <=n ; j++)//这个循环就是找到没有加入S数组中距离源点最短的点
        {
        if(!str[j] && (t == -1 || dis[t] > dis[j])
        t = j;
        }

        for(int j = 1;j <=n; j++)//扩展上面找到的最短的点t,然后扩展它的边,更新里面的距离
        {
            dis[j] = min(dis[j], dis[t] + g[t][j]);//注意dis[j]表示第j点到源点的距离
        }
        str[t] = true;//这个点加入数组S中
    }
    return dis[n];//返回n点到源点的最短距离
}

时间复杂度为(n^2+m),n表示点数,m表示边数

例如: 存在四个点和四条边,权重分别为4,2,3,5.

---

存在的点	dis[j]	最短距离的前一个点
1	0x3f-->0(标记1)	1
2	0x3f-->0x3f-->6(8>6不更新)	4
3	0x3f-->5(标记3)	1
4	0x3f-->4(标记2)	1

0x3f为初始的值无穷大

例题:

单源最短路径(弱化版)

//没有优化,按照上面的代码只能过60%的数据

#include<iostream>
#include<cstring>
#include<cstdio>

using namespace std;

const int N = 1010;

int g[N][N];
int dis[N];
int n, m, s;
bool str[N];

void Dijkstra()
{
    memset(dis, 0x3f, sizeof dis);
    dis[s] = 0;
    for(int i = 0; i < n-1; i++)
    {
        int t = -1;
        for(int j = 1;j <= n;j++)
        {
            if(!str[j] && (t == -1 || dis[t] > dis[j]))
            t = j;
        }
        
        for(int j = 1;j <= n;j++)
        {
            dis[j] = min(dis[j], dis[t] + g[t][j]);
        }
        str[t] = true;
    }
    return;
}
int main()
{
    cin >> n >> m >> s;
    memset(g, 0x3f, sizeof g);
    
    while(m--)
    {
        int a, b, c;
        cin >> a >> b >> c;
        g[a][b] = min(g[a][b], c);
    }
    Dijkstra();
    for(int i = 1;i <= n;i++)
    {
        printf("%d ",dis[i]);
    }
    return 0;
}

优化Dijkstra通过优先队列,小根堆来优化从而降低时间复杂度 (mlogn)

与上面不同点在于,这个通过优先队列来优化,通过邻接表来存储.

typedef pair<int,int> PII;//用pair来存储

int e[N],idx;//表示点的下标
int ne[N];//下一个节点
int h[N];//头结点
int w[N];//权重
int dis[N];//距离源点距离
bool str[N];//这个点的存储

void add(int a,int b,int c)
{
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int Dijkstra()
{
    memset(dis, 0x3f, sizeof dis);
    dis[1]=0;
    priority_queue<PII,vector<PII>,greater<PII>> heap;//优先队列会默认排列
    heap.push({0,1});//第一个数据为距离,第二个数据为点  
    
       while(heap.size())//当队列里面还有数据的时候进入循环
    {  
        auto t = heap.top();
        heap.pop();
        
        int point = t.second,distance = t.first;
        if(str[t])continue;//如果这个点被扩展,则回到while循环
        str[t] = true;
        for(int i = h[point];i!=-1;i = ne[i])//扩展队头的出度
        {
            int j = e[i];// 取出下标值
            if(dis[j] > distance + w[i])//更新距离
            {
                dis[j] = distance + w[i];
                heap.push({dis[j],j});
            }
         }
    return dis[n];//返回源点到n点的最短距离
}
        
        

单源路径(优化版)

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>

using namespace std;
typedef pair<int,int> PII;

const int N = 1e6+10;

int h[N],e[N],ne[N],w[N],idx;
int dis[N];
int n, m, s;
bool str[N];

void add(int a,int b,int c)
{
    e[idx] = b,w[idx] = c,ne[idx] = h[a],h[a] = idx++;
}
void Dijkstra()
{
    memset(dis, 0x3f, sizeof dis);
    dis[s] = 0;
    priority_queue<PII,vector<PII>,greater<PII> > heap;
    heap.push({0,s});
    
    
    while(heap.size())
    {
        PII t = heap.top();
        heap.pop();
    
        int dist = t.first,po = t.second;
    
        if(str[po])continue;
        
        str[po] = true;
        for(int i = h[po];i != -1;i = ne[i])
        {
            int j = e[i];
            if(dis[j] > dist + w[i])
            {
                dis[j] = dist + w[i];
                heap.push({dis[j],j});
            }
        }
    }
    return;
}
int main()
{
    scanf("%d %d %d",&n,&m,&s);
    memset(h, -1, sizeof h);
    
    while(m--)
    {
        int a, b, c;
        scanf("%d %d %d",&a,&b,&c);
        add(a,b,c);
    }
    Dijkstra();
    for(int i = 1;i <= n;i++)
    {
        printf("%d ",dis[i]);
    }
    return 0;
}

加油哦!!!!!