机试算法模板--Dijkstra算法

Dijkstra算法

#include <iostream>
#include <algorithm>
using namespace std;

const int INF = 0x3fffffff; //设INF为一个很大的数
const int maxv = 1000;      //最大顶点数
int n, m, s;
int G[maxv][maxv];
int d[maxv];              //顶点到达各点的最短路径长度
bool vis[maxv] = {false}; //结点是否被访问

void Dijkstra(int s)
{
    fill(d, d + maxv, INF);
    d[s] = 0;
    for (int i = 0; i < n; i++)
    {
        int u = -1;
        int min = INF;
        for (int j = 0; j < n; j++)
        {
            if (vis[j] == false && d[j] < min)
            {
                u = j;
                min = d[j];
            }
        }
        if (u == -1) //没有找到小于INF的d[u]说明剩下的顶点和起点s不连通
        {
            return;
        }
        vis[u] = true;
        for (int v = 0; v < n; v++) //v没有被访问&&以u为中介点可以使起点s到终点v的最短距离减小
        {
            if (vis[v] == false && G[u][v] + d[u] < d[v])
            {
                d[v] = G[u][v] + d[u];
            }
        }
    }
}

int main()
{
    
    int u, v, w;
    cin >> n >> m >> s;                  //顶点个数，边数，起点编号
    fill(G[0], G[0] + maxv * maxv, INF); //初始化图G
    for (int i = 0; i < m; i++)
    {
        cin >> u >> v >> w;
        G[u][v] = w;
    }
    Dijkstra(0);
    for (int i = 0; i < n; i++)
    {
        cout << d[i] << endl;
    }
    return 0;
}

有多条最短路径的情况

使用Dijkstra算法记录所有的最短路径

vector<int> pre[maxv]; //存放每个节点能产生最短路径的前驱节点
void Dijkstra(int s)
{
    fill(dis, dis + maxv, INF);

    for (int i = 0; i < n; i++)
    {
        dis[s] = 0;
        int u = -1;
        int min = INF;
        for (int j = 0; j < n; j++)
        {
            if (vis[j] == false && dis[j] < min)
            {
                u = j;
                min = dis[j];
            }
        }
        if (u == -1) //找不到小于INF的d[u],说明剩下的顶点和起点s不连通
        {
            return;
        }
        vis[u] = true;
        for (int v = 0; v < n; v++)
        {
            if (vis[v] == false && G[u][v] != INF)
            {
                if (dis[u] + G[u][v] < dis[v])
                {
                    dis[v] = dis[u] + G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if (dis[u] + G[u][v] == dis[v]) //找到一条长度相同的路径
                {
                    pre[v].push_back(u);
                }
            }
        }
    }
}

遍历所有最短路径，找出一条使第二标尺最优的路径

int value[maxv];            //各点的救援队数量
int optvalue;               //第二标尺最优值
vector<int> pre[maxv];      //存放每个节点能产生最短路径的前驱节点
vector<int> path, tempPath; //最优路径,临时路径
void DFS(int v)             //v:当前访问节点
{
    if (v == s) //递归边界:如果到达了叶子节点
    {
        tempPath.push_back(v);
        int value1; //存放临时路径上第二标尺的值
        //点权之和
        for (unsigned int i = tempPath.size() - 1; i > 0; i--)
        {
            int id = tempPath[i];
            value1 += value[id];
        }
        if (value1 > optvalue)
        {
            optvalue = value1;
            path = tempPath;
        }
    }
    //递归式
    tempPath.push_back(v);
    for (unsigned int i = 0; i < pre[v].size(); i++)
    {
        int u = pre[v][i];
        DFS(u);
    }
    tempPath.pop_back(); //遍历完所有前驱结点，将当前结点删除
}