最短路径（Dijkstra和堆优化）

https://vjudge.net/contest/299441#problem/A

题意：给出图，求1到n点的最短距离。

 

https://www.cnblogs.com/thousfeet/p/9229395.html

Dijkstra：时间复杂度为O（n^2）

单源最短路径：1、所有节点分为两个集合，已确定最短路的集合P、未知最短路的集合Q。开始，P中只有有源点u这一个节点。

2、在Q集合中选取一个点v加入P集合，该v点离源点u节点最近，然后考虑v点的出边，对集合Q中的点更新到有源点u的距离。

3、重复第二步，直到集合Q为空。最终dis数组的值就是源点到所有顶点的最短路径。

 注意：该算法不能处理会负权边的图。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
#define int ll
#define mod 998244353
#define gcd(m,n) __gcd(m, n)
#define rep(i , j , n) for(int i = j ; i <= n ; i++)
#define red(i , n , j)  for(int i = n ; i >= j ; i--)
#define ME(x , y) memset(x , y , sizeof(x))
int lcm(int a , int b){return a*b/gcd(a,b);}
ll quickpow(ll a , ll b){ll ans=1;while(b){if(b&1)ans=ans*a%mod;b>>=1,a=a*a%mod;}return ans;}
//int euler1(int x){int ans=x;for(int i=2;i*i<=x;i++)if(x%i==0){ans-=ans/i;while(x%i==0)x/=i;}if(x>1)ans-=ans/x;return ans;}
//const int N = 1e7+9; int vis[n],prime[n],phi[N];int euler2(int n){ME(vis,true);int len=1;rep(i,2,n){if(vis[i]){prime[len++]=i,phi[i]=i-1;}for(int j=1;j<len&&prime[j]*i<=n;j++){vis[i*prime[j]]=0;if(i%prime[j]==0){phi[i*prime[j]]=phi[i]*prime[j];break;}else{phi[i*prime[j]]=phi[i]*phi[prime[j]];}}}return len}
#define INF  0x3f3f3f3f
#define PI acos(-1)
#define pii pair<int,int>
#define fi first
#define se second
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define size(v) (int)(v.size())
#define cin(x) scanf("%lld" , &x);
const int N = 1e7+9;
const int maxn = 1e2+9;
const double esp = 1e-6;
int ma[maxn][maxn];//数据范围小，可直接邻接矩阵存图。
int vis[maxn];//标记为集合P中的点
int dis[maxn];//有源点到各点的最短路径
int n , m ;//n个顶点，m条边

void init(){//初始化
    ME(vis, 0);
    fill(ma[0] , ma[0]+maxn*maxn , INF);//没有边相连，初始化为无穷大
}
void dijkstra(int u){//源点
    rep(i , 1 , n){
        dis[i] = ma[i][u];//更新
    }
    vis[u] = 1 ;//放入集合P
    rep(i , 1 , n-1){//进行n-1次选点放入P集合
        int pos ;
        int mi = INF;
        rep(j , 1 , n){//在Q集合中找到一个点，该点到有源点u的距离最短
            if(!vis[j] && mi > dis[j]){
                mi = dis[j];
                pos = j;
            }
        }
        vis[pos] = 1 ;//放入集合P
        rep(j , 1 , n){
            if(!vis[j] && dis[j] > dis[pos] + ma[pos][j]){//通过刚放入集合P的点v，更新Q集合的点到有源点u的距离
                dis[j] = dis[pos] + ma[pos][j];
            }
        }
    }
}

void solve(){
    init();
    rep(i , 1 , m){
        int u , v , w;
        scanf("%lld%lld%lld" , &u , &v , &w);
        ma[u][v] = ma[v][u] = min(ma[u][v] , w);
    }
    dijkstra(1);
    cout << dis[n] << endl;
}

signed main()
{
    //ios::sync_with_stdio(false);
    //int t ;
    //scanf("%lld" , &t);
    //while(t--)
    while(~scanf("%lld%lld" , &n , &m) && n+m)
        solve();
}

 dijkstra堆优化（时间复杂度为O（nlogm）

邻接表建图（链式前向星）适合存储稀疏图。

朴素算法在找点时，需要一重循环在Q集合里找到一点v到有源点u集离最短。而该过程可以通过小根堆进行优化，使得找点时间复杂度降到logn。

使用优先队列实现堆优化。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
#define int ll
#define mod 998244353
#define gcd(m,n) __gcd(m, n)
#define rep(i , j , n) for(int i = j ; i <= n ; i++)
#define red(i , n , j)  for(int i = n ; i >= j ; i--)
#define ME(x , y) memset(x , y , sizeof(x))
int lcm(int a , int b){return a*b/gcd(a,b);}
//ll quickpow(ll a , ll b){ll ans=1;while(b){if(b&1)ans=ans*a%mod;b>>=1,a=a*a%mod;}return ans;}
//int euler1(int x){int ans=x;for(int i=2;i*i<=x;i++)if(x%i==0){ans-=ans/i;while(x%i==0)x/=i;}if(x>1)ans-=ans/x;return ans;}
//const int N = 1e7+9; int vis[n],prime[n],phi[N];int euler2(int n){ME(vis,true);int len=1;rep(i,2,n){if(vis[i]){prime[len++]=i,phi[i]=i-1;}for(int j=1;j<len&&prime[j]*i<=n;j++){vis[i*prime[j]]=0;if(i%prime[j]==0){phi[i*prime[j]]=phi[i]*prime[j];break;}else{phi[i*prime[j]]=phi[i]*phi[prime[j]];}}}return len}
#define INF  0x3f3f3f3f
#define PI acos(-1)
#define pii pair<int,int>
#define fi first
#define se second
#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define size(v) (int)(v.size())
#define cin(x) scanf("%lld" , &x);
const int N = 1e4+9;
const int maxn = 1e2+9;
const double esp = 1e-6;
int head[maxn],tol;//链式前向星
int vis[maxn] , dis[maxn];
int n , m ;
struct Graph{
    int v , w , next;
}g[N<<1];//双向边要开两倍

struct Edge{
    int v , w ;
    bool operator < (const Edge &e) const{
        return w > e.w;
    }
    Edge(int _v , int _w){
        v = _v , w = _w ;
    }
};

void add(int u , int v , int w){//建图
    g[++tol] = {v , w , head[u]};
    head[u] = tol;
}

void dijkstra(int u){
    rep(i , 1 , n) dis[i] = INF;
    dis[u] = 0 ;
    priority_queue<Edge>q;
    q.push(Edge(u , dis[u]));
    while(!q.empty()){
        Edge now = q.top();q.pop();
        if(vis[now.v]) continue;
        vis[now.v] = 1;
        for(int i = head[now.v] ; i ; i = g[i].next){
            int v = g[i].v;
            int w = g[i].w;
            if(!vis[v] && dis[v] > dis[now.v] + w){
                dis[v] = dis[now.v] + w;
                q.push(Edge(v , dis[v]));
            }
        }
    }
}
void init(){
    ME(vis , 0);
    ME(head , 0);
    tol = 0;
}

void solve(){
    init();
    rep(i , 1 , m){
        int u , v , w ;
        scanf("%lld%lld%lld" , &u , &v , &w);
        add(u , v , w);
        add(v , u , w);
    }
    dijkstra(1);
    cout << dis[n] << endl;
}

signed main()
{

    while(~scanf("%lld%lld" , &n , &m) && n+m)
        solve();
}