Dijkstra算法的介绍与总结（来自上机指南）

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

const int MAXV = 1000;//最大顶点数
const int INF = 0x3f3f3f3f; // 设INF为一个很大的数
const int N = 1e6+10;
int n,m,g[MAXV][MAXV]; // n为顶点数，MXAV 为最大顶点数
int dist[MAXV]; // 起点到达各点的最短路径长度

bool vis[MAXV];

typedef pair<int,int>PII;

void dijkstra(int s) // s为起点
{
    memset(dist,0x3f,sizeof dist);
    
    dist[s] = 0;
    
    for(int i = 0;i < n;i++)
    {
        int t = -1;

        for(int j = 1;j <= n;j++)
        {
            if(!vis[j]&&(t==-1||dist[t]>dist[j]))
                t = j;
        }

        // 找不到小于INF的dist[t],说明剩下的顶点和起点s不连通
        if(t==-1)return;
        vis[t] = true; // 标记t 已经被访问过

        for(int v = 1;v <= n;v++)
        {
            // 如果v未访问&&以t为中介可以使dist[v]更优
            if(!vis[v]&&dist[v]>dist[t]+g[t][v])
            {
                dist[v] = dist[t] + g[t][v];
            }
        }

    }
}


// 邻接表版

vector<PII> Adj[N];

void Dijkstra(int s)
{
    memset(dist,0x3f,sizeof dist);

    dist[s] = 0;

    for(int i = 0;i < n;i++)
    {
        int t = -1;

        for(int j = 1;j <= n;j++)
        {
            if(!vis[j]&&(t==-1||dist[t]>dist[j]))
                t = j;
        }

        // 找不到小于INF的dist[t],说明剩下的顶点和起点s不连通
        if(t==-1)return;
        vis[t] = true; // 标记t 已经被访问过

        for(int j = 0;j < Adj[t].size();j++)
        {
            int v = Adj[t][j].first,dis = Adj[t][j].second;
            if(dist[v]>dist[t]+dis)
            {
                dist[v] = dist[t] + dis;
            }
        }
    }
    
}


// 对优化的Dijkstra()
void Dijkstra1(int s)
{
    memset(dist,0x3f,sizeof dist);
    
    dist[1] = 0;
    
    priority_queue<PII,vector<PII>,greater<PII>>heap;
    
    heap.push({0,1});
    
    while(heap.size())
    {
        auto t = heap.top();
        heap.pop();
        
        int dis = t.first,v = t.second;
        
        if(vis[v])continue;
        vis[v] = true;
        
        for(int i = 0;i < Adj[v].size();i++)
        {
            int d = Adj[v][i].first,j = Adj[v][i].second;
            if(dist[j] > dis + d)
            {
                dist[j] =  dis + d;
                heap.push({dist[j],j});
            }
        }
        
    }
    
}


int main()
{

    cin >> n >> m;
    
    memset(g,0x3f,sizeof g);
    
    for(int i = 0;i < m;i++)
    {
        int a,b,c;
        cin >> a >> b >> c;
        g[a][b]  = min(g[a][b],c);
        Adj[a].push_back({c,b});
    }
    
    Dijkstra1(1);
    if(dist[n] == 0x3f3f3f3f)cout << -1 << endl;
    else
    cout << dist[n] << endl;
    return 0;
}

 

// 之前的代码是最短距离的求解，但是还没有讲到最短路径本身怎么求解
// 下面这是最短路径的求法的代码
/*
 * 思路 : 以 t 为中介点可以使起点s到顶点v的最短距离dist[v]更优
 *  也就是dist[v]变得更小的方案是让t从s到v的最短路径v的前一个节点
 *  也就是(s->·····u -> v),这样我们不妨把这个信息记录下来，于是设置数组pre【】
 *  当代码条件成立的时候，就可以将t赋值给pre[v] , pre[v] = t;
 */
int pre[MAXV];
void dijkstra(int s) // s为起点
{
    memset(dist,0x3f,sizeof dist);
    
    dist[s] = 0;
    
    for(int i = 0;i < n;i++)
    {
        int t = -1;

        for(int j = 1;j <= n;j++)
        {
            if(!vis[j]&&(t==-1||dist[t]>dist[j]))
                t = j;
        }

        // 找不到小于INF的dist[t],说明剩下的顶点和起点s不连通
        if(t==-1)return;
        vis[t] = true; // 标记t 已经被访问过

        for(int v = 1;v <= n;v++)
        {
            // 如果v未访问&&以t为中介可以使dist[v]更优
            if(!vis[v]&&dist[v]>dist[t]+g[t][v])
            {
                dist[v] = dist[t] + g[t][v];
                pre[v] = t;
            }
        }

    }
}

void dfs(int s,int v)
{
    if(s==v)
    {
        cout << s << endl;
        return;
    }
    dfs(s,pre[v]);
    cout << v << endl;
}

// 1. 新增边权
/*
 *  用cost[u][v] 表示u-v的花费。并增加一个数组c[],初始化和dist一样
 *  这样在d[u] + g[u][v] < d[v] 时更新d[v]和c[v]
 *  if(d[u] + g[u][v] < d[v])
 *  {
 *      d[v] = d[u] + g[u][v];
 *      c[v] = c[u] + cost[u][v];
 *  }
 *  else if(d[u] == g[u][v] + d[v])
 *  {
 *      c[v] = min(c[v],c[u] + cost[u][v]);
 *  }
 *  
 *  2. 新增点权
 *  用weight[u]表示城市u中物资数目，并增加一个数组w[]，令从起点s到顶点u可以收集
 *  最大物资为w[u],初始化时只有w[s]为weight[s]，其余都为0
 
    if(vis[v] == false && g[u][v]!=INF)
    {
        if(d[u]+g[u][v] < d[v])
        {
            d[v] = d[u] + g[u][v];
            w[v] = w[u] + weight[v];
        }
        else if(d[u] + g[u][v] == d[v]&&w[u] + weight[v] > w[v])
        {
            w[v] = w[u] + weight[v];
        }
    }
   
    3.求最短路径的条数。只需要增加一个数组num[]，令从起点s到达顶点u的最短路径条数
    为num[u],初始化时只有num[s] = 1,其余为0
    
    if(d[u] + g[u][v] < d[v])
    {
        d[v] = d[u] + g[u][v];
        num[v] = num[u];
    }
    else if(d[u] g[u][v] == d[v])
    {
        num[v] = num[v] + num[u]; // 最短距离相同累加num
    }
 
 *  
 * */