图的最短路径之Dijkstra算法

最短路径(Dijkstra)算法 最短路径算法Dijktra 阅读详情

参考:https://wangkuiwu.github.io/2013/04/14/dijkstra-cplus

Dijkstra算法介绍

迪杰斯特拉(Dijkstra)算法是典型最短路径算法,用于计算一个节点到其他节点的最短路径。

它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想),直到扩展到终点为止。

算法基本思想:

通过 Dijkstra 计算图 G 中的最短路径时,需要指定起点 s(即从顶点 s 开始计算)。

此外,还需要引进两个集合 S 和 U。S 的作用是记录已求出最短路径的顶点(以及相应的最短路径长度),而 U 则是记录还未求出最短路径的顶点(以及该顶点到起点 s 的距离)。

起初是,S 中只有顶点 s,U 中是除 s 之外的顶点,并且 U 中顶点的路径是“起点 s 到该顶点顶点路径”。然后,从 U 中找出路径最短的顶点,并将其加入到 S 中;接着,更新 U 中的顶点和顶点对应的路径。然后,再从 U 中找出路径最短的顶点,并将其加入到 S 中;接着,更新 U 中的顶点和顶点对应的路径。… 一直重复这样的工作,直到遍历完所有顶点。

操作步骤:

1)初始时,S 只包含起点 s。U 包含除 s 外的其他顶点,且 U 中顶点的距离为“起点 s 到该顶点的距离”。例如,U 中顶点 v 的距离为 (s, v) 的长度,然后 s 和 v 不相邻,则 v 的距离为 ∞。

2)从 U 中选出“距离最短的顶点 k”,并将顶点 k 加入到 S 中,同时,从 U 中移除顶点 k。

3)更新 U 中各个顶点到起点 s 的距离。之所以更新 U 中顶点的距离,是由于上一步中确定了 k 是求出最短路径的顶点,从而可以利用 k 来更新其它顶点的距离。例如,(s, v) 的距离可能大于 (s, k)+(k, v) 的距离。

4)重复步骤 (2) 和 (3),直到遍历完所有顶点。

单纯的看上面的理论可能比较难以理解,下面通过实例来对该算法进行说明。

Dijkstra算法图解

Dijkstra算法-图1

图 G4

还是以上面的图 G4 为例,来对迪杰斯特拉进行算法演示(以第 4 个顶点 D 为起点)。

Dijkstra算法-图2

过程说明:

初始状态:S 是已计算出最短路径的顶点集合,U 是未计算出最短路径的顶点的集合。

第一步:将顶点 D 加入到 S 中并从 U 中移除,此时 S={ D(0) },此时最短路径 D->D = 0,然后以 D 为中间点,更新 U 中各个顶点到 D 的距离。其中,D->C = 3,D->E = 4,所以:U={ A(∞), B(∞), C(3), E(4), F(∞), G(∞) }。

第二步:上一步之后,U 中距离起点 D 距离最短的是 C,将顶点 C 加入到 S 中并从 U 中移除,此时 S={ D(0), C(3) },此时最短路径 D->D = 0,D->C = 3,然后以 C 为中间点,更新 U 中各个顶点到 D 的距离。其中,B->C->D = 13,F->C->D = 9,E->C->D = 8 >= 4 不做更新,所以:U={ A(∞), B(13), E(4), F(9), G(∞) }。

第三步:上一步之后,U 中距离起点 D 距离最短的是 E,将顶点 E 加入到 S 中并从 U 中移除,此时 S={ D(0), C(3), E(4) },此时最短路径 D->D = 0,D->C = 3,D->E = 4,然后以 E 为中间点,更新 U 中各个顶点到 D 的距离。其中,F->E->D = 6,G->E->D = 12,所以:U={ A(∞), B(13), F(6), G(12) }。

第四步:上一步之后,U 中距离起点 D 距离最短的是 F,将顶点 F 加入到 S 中并从 U 中移除,此时 S={ D(0), C(3), E(4), F(6) },此时最短路径 D->D = 0,D->C = 3,D->E = 4,D->F = 6,然后以 F 为中间点,更新 U 中各个顶点到 D 的距离。其中,A->F->D = 22,G->F->D = 15 >= 12 不做更新,B->F->D = 13 >= 13不做更新,所以:U={ A(22), B(13), G(12) }。

第五步:上一步之后,U 中距离起点 D 距离最短的是 G,将顶点 G 加入到 S 中并从 U 中移除,此时 S={ D(0), C(3), E(4), F(6), G(12) },此时最短路径 D->D = 0,D->C = 3,D->E = 4,D->F = 6,D->G = 12,然后以 G 为中间点,更新 U 中各个顶点到 D 的距离。其中,A->G->D = 26 >= 22 不做更新,B->G->D = ∞ >= 13 不做更新,所以:U={ A(22), B(13) }。

第六步:上一步之后,U 中距离起点 D 距离最短的是 B,将顶点 B 加入到 S 中并从 U 中移除,此时 S={ D(0), C(3), E(4), F(6), G(12), B(13) },此时最短路径 D->D = 0,D->C = 3,D->E = 4,D->F = 6,D->G = 12,B->D = 13,然后以 B 为中间点,更新 U 中各个顶点到 D 的距离。其中,A->B->D = 25 >= 22 不做更新,所以:U={ A(22) }。

第六步:上一步之后,U 中距离起点 D 距离最短的是 A,将顶点 A 加入到 S 中并从 U 中移除,此时 S={ D(0), C(3), E(4), F(6), G(12), B(13), A{22} },此时最短路径 D->D = 0,D->C = 3,D->E = 4,D->F = 6,D->G = 12,B->D = 13,A->D = 22,然后以 B 为中间点,更新 U 中各个顶点到 D 的距离。这时候因为集合 U 已经为空,所以起点 D 到各个顶点的最短距离就计算出来了:A(22), B(13), C(3), D(0), E(4), F(6), G(12)。

Dijkstra算法实现

图的邻接矩阵实现Kruskal算法

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

#define MAX 100
#define INF (~(0x1 << 31)) //无穷大(0x7FFFFFFF)

const int VEXNUM = 7;

struct EData
{
    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重

    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}
};

class MatrixUDG
{
private:
    char mVexs[MAX];       //顶点集合,如:{'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int mVexNum;           //顶点数,如:7
    int mEdgNum;           //边数
    int mMatrix[MAX][MAX]; //邻接矩阵
public:
    //创建图(手动输入)
    MatrixUDG();
    //创建图(用提供的矩阵)
    MatrixUDG(char *vexs, int vNum, int matrix[][VEXNUM]);
    ~MatrixUDG();
    //打印邻接表
    void print();
    //Dijkstra最短路径算法
    void Dijkstra(int vstart, int vexs[], int dist[]);

private:
    //输入一个合法字母
    char readChar();
    //获得一个字母在顶点数组的下标
    int getPosition(char ch);
    //返回顶点v的第一个邻接顶点的索引,失败返回-1
    int firstVertex(int v);
    //范围顶点v相对于w的下一个邻接顶点的索引,失败返回-1
    //比如: A和C, D, E有连接,则A相对于C的下一个结点为D,即返回D的索引
    int nextVertex(int v, int w);
    //获取图中的边
    EData *getEdge();
    //对边按照权值从小到大进行排序
    void sortEdges(EData *edges, int eNum);
    //获取i的终点
    int getEnd(int *vEnds, int i);
};

MatrixUDG::MatrixUDG()
{
    char c1, c2;
    int p1, p2;
    int i, j;
    int weight;

    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgNum;
    if (mVexNum < 1 || mEdgNum < 1 || (mEdgNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    //初始化顶点
    for (i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i] = readChar();
    }
    //初始化边的权值
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            if (i == j)
                mMatrix[i][j] = 0;
            else
                mMatrix[i][j] = INF;
        }
    }
    //初始化边的权值,根据用户输入进行初始化
    for (i = 0; i < mEdgNum; ++i)
    {
        cout << "edge(" << i << "):";
        c1 = readChar();
        c2 = readChar();
        cin >> weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边错误!" << endl;
            return;
        }
        mMatrix[p1][p2] = weight;
        mMatrix[p2][p1] = weight;
    }
}

MatrixUDG::MatrixUDG(char *vexs, int vNum, int matrix[][VEXNUM])
{
    if (!vexs || !*matrix)
        return;
    int i, j;
    mVexNum = vNum;
    //初始化顶点
    for (i = 0; i < mVexNum; ++i)
        mVexs[i] = vexs[i];

    //初始化边
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            mMatrix[i][j] = matrix[i][j];
        }
    }

    //统计边的数目
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = 0; j < mVexNum; ++j)
        {
            if (i != j && mMatrix[i][j] != INF)
            {
                ++mEdgNum;
            }
        }
    }
    mEdgNum /= 2;
}

MatrixUDG::~MatrixUDG()
{
}

int MatrixUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i] == ch)
            return i;
    }
    return -1;
}

char MatrixUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

/*
返回顶点v的第一个邻接顶点的索引,失败返回-1
*/
int MatrixUDG::firstVertex(int v)
{
    if (v < 0 || v > (mVexNum - 1))
        return -1;
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] != 0 && mMatrix[v][i] != INF)
            return i;
    }
    return -1;
}
/*
返回顶点v相对于w的下一个邻接顶点的索引,失败则返回-1
比如:A和C,D,E有连接,则A相对于C的下一个结点为D,即返回D的索引
*/
int MatrixUDG::nextVertex(int v, int w)
{
    if (v < 0 || v > (mVexNum - 1) || w < 0 || w > (mVexNum - 1))
        return -1;
    for (int i = w + 1; i < mVexNum; ++i)
    {
        if (mMatrix[v][i] != 0 && mMatrix[v][i] != INF)
            return i;
    }
    return -1;
}

//获取图中的边
EData *MatrixUDG::getEdge()
{
    int i, j;
    int index = 0;
    EData *edges = new EData[mEdgNum];
    for (i = 0; i < mVexNum; ++i)
    {
        for (j = i + 1; j < mVexNum; ++j)
        {
            if (mMatrix[i][j] != INF)
            {
                edges[index].start = mVexs[i];
                edges[index].end = mVexs[j];
                edges[index].weight = mMatrix[i][j];
                ++index;
            }
        }
    }
    return edges;
}

//对边按照权值大小进行排序(由小到大)
void MatrixUDG::sortEdges(EData *edges, int eNum)
{
    //直接调用STL排序
    std::sort(edges, edges + eNum, [](EData &edge1, EData &edge2) -> bool
              { return edge1.weight < edge2.weight; });
}

int MatrixUDG::getEnd(int *vEnds, int i)
{
    //相当于并查集的操作
    while (vEnds[i] != 0)
    {
        i = vEnds[i];
    }
    return i;
}

/*
* Dijkstra最短路径算法,即统计图中顶点vstart到其他各个顶点的最短路径
* vstart: 起始顶点
* prev: 前驱顶点数组,prev[i]的值是顶点vstart到顶点i的最短路径所经历的全部顶点中,位于顶点i之前的那个顶点
* dist: 存储最短路径的结果数组,dist[i]是顶点vstart到顶点i的最短路径的长度
*/
void MatrixUDG::Dijkstra(int vstart, int prev[], int dist[])
{
    int i, j;
    int k;
    int min;
    int tmp;
    int flag[MAX];
    //初始化
    for (i = 0; i < mVexNum; ++i)
    {
        flag[i] = 0;                  //顶点i的最短路径还没获取到
        prev[i] = 0;                  //顶点i的前驱顶点为0
        dist[i] = mMatrix[vstart][i]; //顶点i的最短路径为顶点vs到顶点i的权
    }
    //对顶点vstart自身进行初始化
    flag[vstart] = 1;
    dist[vstart] = 0;
    //遍历mVexNum-1次,每次找出一个顶点的最短路径
    for (i = 0; i < mVexNum; ++i)
    {
        //寻找当前最小路径,在未获取最短路径的顶点中,寻找离vstart最近的顶点k
        min = INF;
        for (j = 0; j < mVexNum; ++j)
        {
            if (flag[j] == 0 && dist[j] < min)
            {
                min = dist[j];
                k = j;
            }
        }
        //标记顶点k位已经获取到最短路径
        flag[k] = 1;
        // 修正当前最短路径和前驱顶点,即当已经得出顶点k的最短路径之后,更新未获取最短路径的顶点的最短路径和前驱顶点
        for (j = 0; j < mVexNum; ++j)
        {
            tmp = (mMatrix[k][j] == INF ? INF : (min + mMatrix[k][j]));
            if (flag[j] == 0 && (tmp < dist[j]))
            {
                dist[j] = tmp;
                prev[j] = k;
            }
        }
    }
    //打印Dijkstra最短路径的结果
    cout << "Dijkstra(" << mVexs[vstart] << "):" << endl;
    for (i = 0; i < mVexNum; ++i)
    {
        cout << "最短路径(" << mVexs[vstart] << ", " << mVexs[i] << ")=" << dist[i] << endl;
    }
}

void MatrixUDG::print()
{
    for (int i = 0; i < mVexNum; ++i)
    {
        for (int j = 0; j < mVexNum; ++j)
        {
            if (mMatrix[i][j] == INF)
            {
                cout << "INF"
                     << "\t";
            }
            else
            {
                cout << mMatrix[i][j] << "\t";
            }
        }
        cout << endl;
    }
}

int main()
{
    char vexs[VEXNUM] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int matrix[][VEXNUM] = {
        {0, 12, INF, INF, INF, 16, 14},
        {12, 0, 10, INF, INF, 7, INF},
        {INF, 10, 0, 3, 5, 6, INF},
        {INF, INF, 3, 0, 4, INF, INF},
        {INF, INF, 5, 4, 0, 2, 8},
        {16, 7, 6, INF, 2, 0, 9},
        {14, INF, INF, INF, 8, 9, 0}};

    // 1. 根据提供的数据生成
    MatrixUDG mudg(vexs, vNum, matrix);
    mudg.print(); //打印图
    int prev[MAX] = {0};
    int dist[MAX] = {0};
    //Dijkstra算法获得第四个顶点到它各个顶点的最短距离
    mudg.Dijkstra(3, prev, dist);
    //2. 手动生成
    // MatrixUDG mudg1;
    // mudg1.print();
}

运行结果:

$ ./test
0       12      INF     INF     INF     16      14
12      0       10      INF     INF     7       INF
INF     10      0       3       5       6       INF
INF     INF     3       0       4       INF     INF
INF     INF     5       4       0       2       8
16      7       6       INF     2       0       9
14      INF     INF     INF     8       9       0
Dijkstra(D):
最短路径(D, A)=22
最短路径(D, B)=13
最短路径(D, C)=3
最短路径(D, D)=0
最短路径(D, E)=4
最短路径(D, F)=6
最短路径(D, G)=12

图的邻接表实现Kruskal算法

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

#define MAX 100
#define INF (~(0x1 << 31)) //无穷大(0x7FFFFFFF)

const int VEXNUM = 7;

#define MAX 100
#define INF (~(0x1 << 31)) //最大值

struct EData
{
    char start; //边的起点
    char end;   //边的终点
    int weight; //边的权重

    EData() {}
    EData(char s, char e, int w) : start(s), end(e), weight(w) {}
};

class ListUDG
{
private:
    //每一条边
    struct ENode
    {
        int iVex = 0;           //指向的顶点的位置
        int weight = 0;         //该边的权
        ENode *nextEdge = NULL; //指向顶点的下一条边的指针
    };
    //数组中存储的顶点
    struct VNode
    {
        char data;
        ENode *firstEdge = NULL; //指向第一条该顶点的边
    };

private:
    int mVexNum;      //图的顶点数目
    int mEdgeNum;     //图的边的数目
    VNode mVexs[MAX]; //存储顶点
public:
    //创建邻接表对应的图(自己收入)
    ListUDG();
    //创建邻接表对应的图(用已提供的数据)
    ListUDG(char *vexs, int vNum, EData *edges[], int eNum);
    ~ListUDG();
    //打印邻接表
    void print();
    //Dijkstra最短路径算法
    void Dijkstra(int vstart, int vexs[], int dist[]);

private:
    //读取一个合法的输入字符
    char readChar();
    //返回字符ch在的位置
    int getPosition(char ch);
    //将node结点链接到list的最后
    void linkLast(ENode *list, ENode *node);
    //获取边<start, end>的权值,若start和end不是连通的,则返回无穷大
    int getWeight(int start, int end);
    //获取图中的边
    EData *getEdges();
    //对边按照权值从小到大进行排序
    void sortEdges(EData *edges, int eNum);
    //获取i的终点
    int getEnd(int *vEnds, int i);
};

ListUDG::ListUDG()
{
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    int weight;

    cout << "输入顶点数:";
    cin >> mVexNum;
    cout << "输入边数:";
    cin >> mEdgeNum;
    if (mVexNum > MAX || mEdgeNum > MAX || mVexNum < 1 || mEdgeNum < 1 || (mEdgeNum > (mVexNum * (mVexNum - 1))))
    {
        cout << "输入有误!" << endl;
        return;
    }
    //初始化邻接表的顶点
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << "vertex(" << i << "):";
        mVexs[i].data = readChar();
        mVexs[i].firstEdge = NULL;
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        cout << "edge(" << j << "):";
        c1 = readChar();
        c2 = readChar();
        cin >> weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);

        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }
        //初始化node1
        node1 = new ENode();
        node1->iVex = p2;
        node1->weight = weight;
        //将node1链接到p1所在链表的末尾
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        //初始化node2
        node2 = new ENode();
        node2->iVex = p1;
        node2->weight = weight;
        //将node2链接到p2所在链表的末尾
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::ListUDG(char *vexs, int vNum, EData *edges[], int eNum)
{
    if (vNum > MAX || eNum > MAX)
        return;
    char c1, c2;
    int p1, p2;
    ENode *node1, *node2;
    int weight;
    //初始化顶点数和边数
    mVexNum = vNum;
    mEdgeNum = eNum;
    //初始化邻接表的顶点
    for (int i = 0; i < mVexNum; ++i)
    {
        mVexs[i].data = vexs[i];
        mVexs[i].firstEdge = NULL;
    }
    //初始化邻接表的边
    for (int j = 0; j < mEdgeNum; ++j)
    {
        //读取边的起始顶点和结束顶点
        c1 = edges[j]->start;
        c2 = edges[j]->end;
        weight = edges[j]->weight;

        p1 = getPosition(c1);
        p2 = getPosition(c2);
        if (p1 == -1 || p2 == -1)
        {
            cout << "输入的边有错误!" << endl;
            return;
        }
        //初始化node1
        node1 = new ENode();
        node1->iVex = p2;
        node1->weight = weight;
        //将node1链接到p1所在的链表末尾
        if (mVexs[p1].firstEdge == NULL)
            mVexs[p1].firstEdge = node1;
        else
            linkLast(mVexs[p1].firstEdge, node1);
        //初始化node2
        node2 = new ENode();
        node2->iVex = p1;
        node2->weight = weight;
        //将node2链接到p2所在链表末尾
        if (mVexs[p2].firstEdge == NULL)
            mVexs[p2].firstEdge = node2;
        else
            linkLast(mVexs[p2].firstEdge, node2);
    }
}

ListUDG::~ListUDG()
{
}

void ListUDG::linkLast(ENode *list, ENode *node)
{
    ENode *p = list;
    while (p->nextEdge)
        p = p->nextEdge;
    p->nextEdge = node;
}

int ListUDG::getPosition(char ch)
{
    for (int i = 0; i < mVexNum; ++i)
    {
        if (mVexs[i].data == ch)
            return i;
    }
    return -1;
}

char ListUDG::readChar()
{
    char ch;
    do
    {
        cin >> ch;
    } while (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')));
    return ch;
}

int ListUDG::getWeight(int start, int end)
{
    if (start == end)
        return 0;
    ENode *node = mVexs[start].firstEdge;
    while (node != NULL)
    {
        if (end == node->iVex)
        {
            return node->weight;
        }
        node = node->nextEdge;
    }
    return INF;
}

//获得图中的边
EData *ListUDG::getEdges()
{
    int i;
    int index = 0;
    ENode *node = NULL;
    EData *edges = new EData[mEdgeNum];
    for (i = 0; i < mVexNum; ++i)
    {
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            if (node->iVex > i)
            {
                edges[index].start = mVexs[i].data;
                edges[index].end = mVexs[node->iVex].data;
                edges[index].weight = node->weight;
                ++index;
            }
            node = node->nextEdge;
        }
    }
    return edges;
}

//对边按照权值大小进行排序(由小到大)
void ListUDG::sortEdges(EData *edges, int eNum)
{
    if (!edges)
        return;
    //直接调用STL排序
    std::sort(edges, edges + eNum, [](EData &edge1, EData &edge2) -> bool
              { return edge1.weight < edge2.weight; });
}

int ListUDG::getEnd(int *vEnds, int i)
{
    //相当于并查集的操作
    while (vEnds[i] != 0)
    {
        i = vEnds[i];
    }
    return i;
}

/*
* Dijkstra最短路径算法,即统计图中顶点vstart到其他各个顶点的最短路径
* vstart: 起始顶点
* prev: 前驱顶点数组,prev[i]的值是顶点vstart到顶点i的最短路径所经历的全部顶点中,位于顶点i之前的那个顶点
* dist: 存储最短路径的结果数组,dist[i]是顶点vstart到顶点i的最短路径的长度
*/
void ListUDG::Dijkstra(int vstart, int prev[], int dist[])
{
    int i, j;
    int k;
    int min;
    int tmp;
    int flag[MAX]; // flag[i]=1表示顶点vstart到顶点i的最短路径已成功获取
    //初始化
    for (i = 0; i < mVexNum; ++i)
    {
        flag[i] = 0;                    //顶点i的最短路径还没获取到
        prev[i] = 0;                    //顶点i的前驱顶点为0
        dist[i] = getWeight(vstart, i); //顶点i的最短路径为顶点vs到顶点i的权
    }
    //对顶点vstart自身进行初始化
    flag[vstart] = 1;
    dist[vstart] = 0;
    //遍历mVexNum-1次,每次找出一个顶点的最短路径
    for (i = 0; i < mVexNum; ++i)
    {
        //寻找当前最小路径,在未获取最短路径的顶点中,寻找离vstart最近的顶点k
        min = INF;
        for (j = 0; j < mVexNum; ++j)
        {
            if (flag[j] == 0 && dist[j] < min)
            {
                min = dist[j];
                k = j;
            }
        }
        //标记顶点k位已经获取到最短路径
        flag[k] = 1;
        // 修正当前最短路径和前驱顶点,即当已经得出顶点k的最短路径之后,更新未获取最短路径的顶点的最短路径和前驱顶点
        for (j = 0; j < mVexNum; ++j)
        {
            tmp = getWeight(k, j);
            tmp = (tmp == INF ? INF : (min + tmp));
            if (flag[j] == 0 && (tmp < dist[j]))
            {
                dist[j] = tmp;
                prev[j] = k;
            }
        }
    }
    //打印Dijkstra最短路径的结果
    cout << "Dijkstra(" << mVexs[vstart].data << "):" << endl;
    for (i = 0; i < mVexNum; ++i)
    {
        cout << "最短路径(" << mVexs[vstart].data << ", " << mVexs[i].data << ")=" << dist[i] << endl;
    }
}

void ListUDG::print()
{
    ENode *node;
    for (int i = 0; i < mVexNum; ++i)
    {
        cout << i << "(" << mVexs[i].data << "):";
        node = mVexs[i].firstEdge;
        while (node != NULL)
        {
            cout << node->iVex << "(" << mVexs[node->iVex].data << ")";
            node = node->nextEdge;
        }
        cout << endl;
    }
}

int main(int argc, char **argv)
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
    EData *edges[] = {
        new EData('A', 'B', 12),
        new EData('A', 'F', 16),
        new EData('A', 'G', 14),
        new EData('B', 'C', 10),
        new EData('B', 'F', 7),
        new EData('C', 'D', 3),
        new EData('C', 'E', 5),
        new EData('C', 'F', 6),
        new EData('D', 'E', 4),
        new EData('E', 'F', 2),
        new EData('E', 'G', 8),
        new EData('F', 'G', 9),
    };
    int vNum = sizeof(vexs) / sizeof(vexs[0]);
    int eNum = sizeof(edges) / sizeof(edges[0]);
    //1. 根据提供的数据生成
    ListUDG ludg(vexs, vNum, edges, eNum);
    ludg.print();
    int prev[MAX] = {0};
    int dist[MAX] = {0};
    //Dijkstra算法获得第四个顶点到它各个顶点的最短距离
    ludg.Dijkstra(3, prev, dist);
    //2. 手动输入
    // ListUDG ludg;
    // ludg.print();
    return 0;
}

运行结果:

$ ./test
0(A):1(B)5(F)6(G)
1(B):0(A)2(C)5(F)
2(C):1(B)3(D)4(E)5(F)
3(D):2(C)4(E)
4(E):2(C)3(D)5(F)6(G)
5(F):0(A)1(B)2(C)4(E)6(G)
6(G):0(A)4(E)5(F)
Dijkstra(D):
最短路径(D, A)=22
最短路径(D, B)=13
最短路径(D, C)=3
最短路径(D, D)=0
最短路径(D, E)=4
最短路径(D, F)=6
最短路径(D, G)=12
数据结构与算法 —— 最短路径Dijkstra算法(迪杰斯特拉)详细图解以及python实现 前两章我们讲到了关于图的基本知识,和广度/深度优先搜索。本章,我们将介绍加权图和最短路径的相关知识。最短路径和最小生成树是图论中常见的问题。最短路径是指在一个图中找到两个节点之间的最短路径,最小生成树是指在一个图中找到一个连通子图,使得所有节点都能够互相到达,且总权值最小。最短路径算法常见的有floyd算法(弗洛伊德算法)和 dijkstra算法(迪杰斯特拉)。本文只介绍dijkstra算法。最短路径运用非常广泛,比如在导航系统中,确定两个地点间哪条路线最短; 阅读详情

相关推荐

图论:Dijkstra算法——最详细的分析,图文并茂,一次看懂!

Dijstra算法

普罗米修斯的博客 18万+

Dijkstra最短路径算法

迪杰斯特拉(Dijkstra)算法是一种用于在加权图中找到单源最短路径的算法。

bairui6666的博客 4512

详解图的最短路径算法(BFS、Dijkstra、Floyd)(附上图解步骤)

详解图的最短路算法、针对BFS、Dijkstra、Floyd算法写出详细的图解、解题步骤

叶小树咯 8105

图算法——求最短路径(Dijkstra算法)

图解Dijkstra算法,让你了解Dijkstra算法的每一步是怎么进行的

在夜里行走的博客 13万+

图-最短路径—Dijkstra算法和Floyd算法

一、Dijkstra算法 1.定义概览:单源最短路径算法 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法,算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题,算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算...

凌凌小博客 2008

数据结构——Dijkstra算法(寻找图的最短路径)

Dijkstra算法 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法,用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法,在很多专业课程中都作为基本内容有详细的介绍,如数据结构,图论,运筹学等等。注意该算法要求图中不存在负权边。 问题描述:在无向图 G=(V,E) 中,假设每条边

Sc2Player的博客 3559

图的最短路径的Dijkstra算法及Floyd算法

文章目录

薛定谔的猫的博客 1490

算法导论随笔(八):图的最短路径问题与Dijkstra算法

在上一篇文章中,我介绍了图(Graph)的概念。这篇文章和未来几篇文章中,我主要讨论关于图的一些经典问题和解决这些问题的经典算法。首先是图的最短路径问题。 1. 图的最短路径(Shortest Path)问题 首先来讨论图的最短路径问题。举一个例子,我们可以把中国的地图看做一个图,把每一个城市看做图中的一个顶点,把相邻城市的高速公路当做一条边。那么,如果我想从北京出发去上海,要经过哪些城市才能使得走过的距离最短呢? 这就是图的最短路径问题。给定一个图,图中每一条边都有一个权重(weight)。比如上面的例子

天降风云的博客 1101

用Dijkstra算法找到图上两点之间的最短路径

Finding the shortest path between two points on a graph is a common problem in data structures, especially when dealing with optimization. 在数据结构中,尤其是在处理优化时,通常要在图形上找到两点之间的最短路径。 A graph is a series of...

1388

基于邻接矩阵存储的图的最短路径问题(Dijkstra算法)

#include using namespace std; #define MAXNODE 500//最大顶点个数 #define Inf 65535//无穷大 typedef int vertype; struct VerNode { vertype vertex;//// 顶点信息,可以是字母表示,也可以是数字表示 //.....;//// 和顶点相关的其它信息,如顶点的度

a946665026的专栏 2961

掌握Dijkstra算法:图最短路径求解

Dijkstra算法是计算机科学中的一个经典算法,用于在图中找到一个节点到其他所有节点的最短路径。这个算法由荷兰计算机科学家艾兹赫尔·戴克斯特拉(Edsger W. Dijkstra)于1956年提出,并在1959年发表。Dijkstra算法可以处理有向和无向图,但在图中不能存在负权重边,因为这可能导致算法陷入无限循环。图是由顶点集合和边集合组成的数据结构。图中的每一条边是顶点对之间的有序或无序的对。根据边的方向,图可以分为有向图和无向图;根据边的权重,图又可以分为有权图和无权图。

weixin_34725745的博客 377

python图最短路径_python数据结构与算法——图的最短路径(Dijkstra算法)

# Dijkstra算法——通过边实现松弛# 指定一个点到其他各顶点的路径——单源最短路径# 初始化图参数G = {1:{1:0, 2:1, 3:12},2:{2:0, 3:9, 4:3},3:{3:0, 5:5},4:{3:4, 4:0, 5:13, 6:15},5:{5:0, 6:4},6:{6:0}}# 每次找到离源点最近的一个顶点,然后以...

weixin_39602737的博客 1323

PCB设计之ODB++文件格式详解

ODB++(Open Database++)是一种广泛应用于PCB(印制电路板)设计和制造领域的开放数据交换格式。它由Valor Computerized Systems(现为Siemens EDA的一部分)开发,旨在替代传统的Gerber文件格式,提供更完整、结构化的制造数据,从而优化PCB设计到生产的流程。ODB++通过结构化数据整合了PCB设计到制造的全流程信息,显著提高了生产效率和准确性。尽管存在一定的兼容性挑战,但其在复杂项目和高可靠性场景中的价值不可替代。

ZZcppc的博客 1万+

数据结构复习指导之图的最短路径(Dijkstra算法和Floyd算法)

本节是历年考查的重点。图的应用主要包括:最小生成(代价)树、最短路径、拓扑排序和关键路径。一般而言,这部分内容直接以算法设计题形式考查的可能性极小,而更多的是结合图的实例来考查算法的具体操作过程,读者必须学会手工模拟给定图的各个算法的执行过程。此外,还需掌握对给定模型建立相应的图去解决问题的方法。

心碎烤肠的博客 1313

DEM数据下载,拼接,裁剪

目录: 1、数字高程模型(DEM)的数据下载 2、在ENVI里面进行拼接,生成SARscape标准格式的DEM数据3、在ArcGIS里面安装已有的矢量范文,进行掩膜裁剪 4、注意事项 数字高程模型的数据下载: 网址:http://dwtkns.com/srtm30m/ 1.对研究区域进行经纬度选择,然后进行选择下载即可 2.下载的数据是.hgt格式的,按照不同的需求进行转换,这里我是用于ENVI处理,且下载了四个,所有进行了拼接,拼接、格式转换如下 注:可能有时候需要登陆注册,点击下...

weixin_40874151的博客 2万+

RS485设备联网避坑指南:塔石串口服务器在MODBUS平台中的3个关键配置项

本文针对塔石串口服务器在MODBUS物联网平台接入中的常见问题,详细解析了三个关键配置项:工作模式选择、远程端口与保活机制、寄存器映射与轮询策略。通过对比错误与正确配置案例,帮助工程师避开配置陷阱,实现RS-485设备的稳定、高效联网,提升批量部署的成功率与系统可靠性。

weixin_29281941的博客 410

图的最短路径算法Dijkstra算法

#include #include #define QUEUE_MAXSIZE 30 #define VERTEX_MAX 26 #define MAXVALUE 99999 typedef struct { char Vertex[VERTEX_MAX];//保存顶点信息,序号或字母 int Edges[VERTEX_MAX][VERTEX_MAX

yaoxiaokui的专栏 607

HAL库硬件SPI驱动ST7735 TFT屏幕:从零实现高效刷屏与图形绘制

本文详细介绍了如何使用STM32的HAL库硬件SPI驱动ST7735 TFT屏幕,从硬件连接到SPI配置优化,再到图形绘制与文本显示的实现。重点分享了DMA传输、局部刷新等高级优化技巧,显著提升刷屏效率,帮助开发者快速掌握屏幕驱动技术并应用于实际项目。

pink的博客 741

图的有权最短路径及Dijkstra算法

图的有权最短路径 和有向无权图不同的是,有向有权图相邻两个顶点间的边上被赋予一个连接权值。 有权最短路径就是寻找一条路径使得该路径上的权值相加与其他路径相比最小。 例如: 上图,顶点v0v0v_0和v5v5v_5之间存在多条路径,如v0→v3→v5v0→v3→v5v_0 \to v_3 \to v_5、v0→v3→v6→v5v0→v3→v6→v5v_0 \to v_3 \to v_6 \t...

SanFancsgo的博客 5539

从数据读取到业务事件:理解 ABAP CDS 视图的目的与选型(含 RAP、扩展与分析场景)

CDS视图在SAP S/4HANA中不仅是数据查询工具,更是语义模型和运行时能力的载体。它通过分层架构(基础视图、组合视图、消费视图等)实现数据复用与场景适配,支持UI、分析、事务处理等多样化消费。视图类型包括提供数据访问的接口视图(I_前缀)、消费视图(C_前缀)和事务视图,以及不提供数据访问的扩展视图。这种分层设计确保了数据模型的稳定性与扩展性,同时支持自定义字段和上下文感知分析。正确理解CDS视图的用途和分层规则,能帮助开发者构建更健壮、可维护的SAP应用。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 303

2024年12月 Python(四级)真题解析#中国电子学会#全国青少年软件编程等级考试

他尝试编写了如下程序,请你完善划线处的代码,计算出在h点s分放学时,三个时针分别经过3点位置的次数,用一个元组表示各指针经过3点位置的次数 (时针次数,分针次数,秒针次数) ,并输出。所谓角谷猜想,是指对于任意一个正整数,如果是奇数,则乘3加1,如果是偶数,则除以2,得到的结果再按照上述规则重复处理,最终总能够得到1。匿名函数,冒号之前表示的是这个函数的参数,冒号之后表示返回值,可以使用默认值,使用时需要将它赋值给一个变量,设置默认值不是必须,如无传入实参则使用默认值,如有传入实参则使用实参。

人生就是一个不断学习的过程 372

图的最短路径算法:Dijkstra算法详解

Dijkstra算法是解决最短路径问题的经典方法,适用于无负权边的图。通过理解其原理、实现方法和优化技巧,我们可以更好地应用它解决实际问题。无论是路由算法、地图导航还是资源分配,Dijkstra算法都发挥着重要作用。

共产主义接班人 1411

RT-Thread littefs控制GD32F4xx片内Flash

GD32F4xx RT-Thread下使用littefs 控制片内flash 调试记录

madao1234的博客 995

图的最短路径——-Dijkstra算法、Bellman-Ford算法

最短路径问题:从在带权有向图G中的某一顶点出发,找出一条通往另一顶点的最短路径,最短也就是 沿路径各边的权值总和达到最小。一、单源最短路径--Dijkstra算法1、概念单源最短路径问题:给定一个图G = ( V , E ) G=(V,E)G=(V,E),求源结点s ∈ V s∈Vs∈V到图 中每个结点v ∈ V v∈Vv∈V的最短路径。Dijkstra算法就适用于解决带权重的有向图上的单源最短 路径问题,同时算法要求图中所有边的权重非负。

2301_80687320的博客 989

MATLAB - ROS 2 工具箱入门教程

ROS 工具箱提供了一个连接 MATLAB® 和 Simulink® 与机器人操作系统(ROS 和 ROS 2)的接口。利用该工具箱,您可以设计 ROS 节点网络,并将 MATLAB 或 Simulink 生成的 ROS 节点与现有的 ROS 网络相结合。工具箱包括 MATLAB 函数和 Simulink 块,可通过记录、导入和回放 rosbag 文件来可视化和分析 ROS 数据。您还可以连接到实时 ROS 网络,访问 ROS 消息。

机器人控制与仿真应用 3070

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

上一篇: 图的最小生成树之Kruskal算法
下一篇: 图的最短路径之Floyd算法
code_peak
博客等级 码龄5年 403粉丝 67原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值