Dijkstra算法

目录

LeetCode743 网络延迟时间

LettCode1776 到达目的地的方案数

LeetCode743 网络延迟时间

/*
 * @lc app=leetcode.cn id=743 lang=cpp
 *
 * [743] 网络延迟时间
 */

// @lc code=start
#include<iostream>
#include<vector>
#include<queue>
using namespace std;

class Solution {
//Dijkstra算法
private:
    struct vertex{
        int num;
        int dis;
        bool operator< (const vertex& p)const{
            return dis>p.dis;
        }
    };
    struct edge{
        int to;
        int weight; 
    };
public:
    int networkDelayTime(vector<vector<int>>& times, int n, int k){
        vector<vector<edge>> g(n+1);
        vector<vertex> vert(n+1);
        priority_queue<vertex>q;
        for(int i=0;i<times.size();i++){
            edge e;
            int u=times[i][0],v=times[i][1],w=times[i][2];
            e.to=v;
            e.weight=w;
            g[u].push_back(e);
        }
        for(int i=1;i<=n;i++){
            vert[i].num=i;
            vert[i].dis=INT_MAX;
        }
        vert[k].dis=0;
        q.push(vert[k]);
        while(!q.empty()){
            int cur=q.top().num;
            q.pop();
            for(int i=0;i<g[cur].size();i++){
                int y=g[cur][i].to;
                int d=g[cur][i].weight;
                if(vert[y].dis>vert[cur].dis+d){
                    vert[y].dis=vert[cur].dis+d;
                    q.push(vert[y]);
                }
            }
        }
        int res=0;
        for(int i=1;i<=n;i++){
            if(vert[i].dis==INT_MAX)return -1;
            res=max(res,vert[i].dis);
        }
        return res;
    }
};

时间复杂度：O(m logn+n)，n为点数,m为边数

空间复杂度：O(m)

LettCode1776 到达目的地的方案数

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

class Solution {
public:
    int countPaths(int n, vector<vector<int>>& roads) {
        long long mod=1e9+7;
        vector<vector<pair<int,int>>> g(n);//邻接表,<邻居，与邻居的距离>
        for(auto &t:roads){//建图
            int from=t[0],to=t[1],d=t[2];
            g[from].emplace_back(to,d);
            g[to].emplace_back(from,d);
        }
        vector<long long> dis(n,LLONG_MAX);
        dis[0]=0;
        vector<int> ways(n);
        ways[0]=1;
        priority_queue<pair<long long,int>,vector<pair<long long,int>>,greater<pair<long long,int>>> q;
        //<与0的距离，节点>,按照pair的第一个元素进行排序,小的在前
        q.emplace(0,0);
        while(!q.empty()){
            auto [t,u]=q.top();//u为当前节点，t为u到0的距离
            q.pop();
            for(auto &[v,w]:g[u]){//v是u的邻居节点，w是v与u的距离
                if(t+w<dis[v]){
                    dis[v]=t+w;
                    ways[v]=ways[u];
                    q.emplace(t+w,v);
                }
                else if(t+w==dis[v]){
                    ways[v]=(ways[u]+ways[v])%mod;
                }
            }
        }
        return ways[n-1];
    }
};