算法培训 Day4-1 迪杰斯特拉

算法培训 Day4-1 迪杰斯特拉

迪杰斯特拉算法

一般来说 做图论的题 采用邻接矩阵 或者 邻接表来解决

这里学习了一种新的方法 链式前向星

int maxn = 1000；
int maxm = 2000；
struct Edge{
    int v,next;//next 指出下一条边的编号
    long long len;
}e[maxm];

int head[maxn];//存放编号为i 的最后一条边的编号
int cnt = 0;
void addedge(int from,int to,long long len)
{
    cnt++;//第几条边
    e[cnt].v = to;
    e[cnt].len = len;
    e[cnt].next = head[from];//从后往前  指向上一条边
    head[from] = cnt;//指向最后一条边
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    int u,v,len;
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&u,&v,&len);
        addedge(u,v,len);
    }
    
    //遍历所有边
    int u=1;//从第一个点开始
    for(int i=head[u];i;i=e[i].next)
    {//从后往前 然后找到上一条相连的边
     // 直到最后 第一条的上一条边为 初始化的0
    }
    
}

一般的迪杰斯特拉的时间复杂度为 O(n ^ 2),当点的数目超过10^4时 时间会超过 1s 因为计算机一秒运算的量级为 10^8

所以需要进行改进，这里使用了优先队列（实质为堆 并且会自动排序）

priority_queue<int> Q;//等价于下面
=>priority_queue <int ,vector<int>,less<int> > Q;
//这是按照降序排列 即产生大顶堆  最上面元素为最大的

priority_queue<int,vector<int>,greater<int> > Q;
//按照升序排列 产生小顶堆

//如果其中的元素为结构体 则需要重载运算符
struct node{
    int a,b,c;
    bool operator < (const node &x) const {
        return a < x.a;
    }
    bool operator > (const node &x) const {
        return a > x.a;
    }
};

同样可以采用 set 也是会自动排序，这样使得算法复杂度为 O( N log N)

且需要优化 加入 vis数组 可以减少重复访问

下面是源码

#include<bits/stdc++.h>
using namespace std;
#define INF 0xffffffff
const int maxn = 100000+100;
const int maxm = 200000+100;
struct Node{
    int u;
    long long dis;//表示从起点到u的距离
    bool operator > (const Node &x) const{
        return dis > x.dis;
    }
    //优先队列 greater  是小顶堆  重载 >
    //默认是大顶堆 采用less  重载 <
};
struct edge{
    int v,next;
    long long len;
}e[maxm];
int head[maxn];
bool vis[maxn];
long long dis[maxn];
int n,m,s;
int cnt=0;
void addedge(int from,int to,int len)
{
    cnt++;
    e[cnt].v = to;
    e[cnt].len = len;
    e[cnt].next = head[from];
    head[from] = cnt;
}
void Djstra()
{
    priority_queue<Node ,vector<Node>,greater<Node> > Q;
    //这样是小顶堆

    //priority_queue<Node> Q;
    //这样是大顶堆
    //采用的是less   若使其变成小顶堆
    //要将 >  < 的意义互换
    for(int i=1;i<=n;i++)
        dis[i] = INF;

    dis[s] = 0;
    Q.push(Node{s,0});
    //优先队列 push 起点
    while(!Q.empty()){
        Node temp = Q.top();
        Q.pop();
        //用优先队列自动排队
        //然后取出dis 最小的点
        if(vis[temp.u])
            continue;
        vis[temp.u] = true;
        //这点是否被当过中转点访问 
        //遍历这个点的所有边  i是边的序号
        for(int i=head[temp.u];i;i=e[i].next){
            int v = e[i].v;
            long long len = e[i].len;
            //这条边 另一个点也没有被访问
            if(!vis[v] && dis[v] > dis[temp.u]+len){
                dis[v] = dis[temp.u] + len;
                Q.push(Node{v,dis[v]});
            }
        }
    }


}

int main()
{
    scanf("%d%d%d",&n,&m,&s);
    int u,v;
    long long len;
    for(int i=1;i<=m;i++){
        scanf("%d%d%lld",&u,&v,&len);
        addedge(u,v,len);
    }
    Djstra();
    for(int i=1;i<=n;i++){
        printf("%lld ",dis[i]);
    }
    return 0;
}