算法思想

  ①从一个源点开始,找距离它最近的点顶点v

  ②然后以顶点v为起点,去找v能到达的顶点w,即v的邻居

  比较源点直接到 v的距离和(源点到v的距离+v到w的距离)

  若大于后者则更新源点的到w的开销

  ③然后去掉这个顶点v,去寻找下一个到距离源点最近的顶点重复②

    最后更新完所有顶点


算法思路

  1.用邻接表或者一个二维数组(邻接矩阵)来存储图

  2.设置dist存储到源点的最短距离

     known标记顶点是被处理

     path记录路径(到达该顶点的上一个顶点)

  3.这步的实现和算法思想中描述的一样

  4.递归显示出源点到各个顶点的路径


代码实现

  下面是完整的代码实现,分别用了邻接表和邻接矩阵来存图

  样图如下

  

  邻接矩阵存图
#include <iostream>
#include <cstdlib>

#define Infinity 10000
#define VERSIZE  8
#define notvertex -1

using namespace std;
typedef int  Vertex;

int dist[VERSIZE];//存储各顶点到源点的最短距离
bool S[VERSIZE];//将处理过的顶点设置为true
Vertex path[VERSIZE];//存储到该顶点的上一个顶点

void ReadGraph(int Graph[VERSIZE][VERSIZE], int m)// 边m
{
    ;
    Vertex u, v;
    int weight;
    ; i <= m; i++)
    {
        cout << "请输入第" << i << "条边:";
        cin >> u >> v;
        cout << "请输入边(" << u << "," << v << ")的权重:";
        cin >> weight;
        Graph[u][v] = weight;
    }
}

//在没处理过的顶点里 找出距离源点最近的顶点
Vertex FindMinIndex()
{
    int min = Infinity;
    Vertex min_index = ;
    ; i< VERSIZE; i++)
    {
        if (!S[i] && dist[i]<min)
        {
            min = dist[i];
            min_index = i;
        }
    }
    return min_index;
}
//算法关键
void Dijkstra(int Graph[VERSIZE][VERSIZE], Vertex source)
{
    ;
    // 初始化数组  从顶点为1开始能直接到达source的 初始化dis数组 0代表不可达
    ; i < VERSIZE; i++)
    {
        dist[i] = (Graph[source][i] ==  ? Infinity : Graph[source][i]);
        S[i] = false;
        if (dist[i] != Infinity)
            path[i] = source;
        else
            path[i] = notvertex;
    }

    //源点到自身
    dist[source] = ;
    S[source] = true;

    //循环VERSIZE-1次
    ; count < VERSIZE; count++)
    {
        Vertex u = FindMinIndex();//找出距离源点最近的顶点
        S[u] = true;//标记为已知

        ; v < VERSIZE; v++)
        {
             && !S[i])//u可达v 且 v未知
            {
                if (dist[v] >(Graph[u][v] + dist[u]))
                {
                    dist[v] = Graph[u][v] + dist[u];
                    path[v] = u;
                }
            }
        }
    }
}

void PrintDist(Vertex source)
{
    ;
    printf("Source   vertex Dist\n");
    ; i< VERSIZE; i++)
    {
        if (dist[i] != Infinity)
            printf("%d    ->    %d\t%d\n", source, i, dist[i]);
        else
            printf("%d    ->    %d\tInfinity\n", source, i);

    }
}

//输出路径
void PrintPath(int v)
{
    if (path[v] != notvertex)
    {
        PrintPath(path[v]);
        printf("--->");
    }
    printf("%d", v);
}

int main()
{
     ,j=;
    };
    ; i < VERSIZE; i++)//初始化二维数组
    {
        ; j < VERSIZE; j++)
            Graph[i][j] = ;
    }

    ReadGraph(Graph, );
    Dijkstra(Graph, );//源点是1
    PrintDist();
    printf("源点1顶点7的路径:\n");
    PrintPath();//打印从源点到顶点7的路径
    system("pause");
    ;
}

运行结果

  

  邻接表存图
#include <iostream>
#include <cstdlib>

#define VERSIZE 8
#define NotVertex -1
#define Infinity 100000

using namespace std;

typedef int Vertex;

typedef struct vernode VerNode;//定义顶点结构
typedef struct tablelist Table;//定义邻接表

struct vernode
{
    Vertex ver;
    int weight;//权重
    VerNode * pNext;
};

struct tablelist
{
    VerNode header;
    bool known;
    int dist;
    Vertex path;
}T[VERSIZE];

//初始化标表+读图
void InitTable(Table T[], int n, int m)//顶点数n 边数m
{
    ;
    ; i <= n; i++)//初始化表头
    {
        T[i].header.ver = i;
        T[i].header.weight = ;//到自身的权重为0
        T[i].header.pNext = NULL;
        T[i].dist = Infinity;
        T[i].known = false;
        T[i].path = NotVertex;
    }
    Vertex u, v;//边(u,v)
    ;
    VerNode * ptemp;
    ; i <= m; i++)
    {
        cout << "请输入第" << i << "条边:";
        cin >> u >> v;
        cout << "请输入边(" << u <<","<< v << ")的权重:";
        cin >> wei;
        ptemp = (VerNode*)malloc(sizeof(VerNode));
        ptemp->ver = v;
        ptemp->weight = wei;
        ptemp->pNext = T[u].header.pNext;
        T[u].header.pNext = ptemp;
    }
}

//找出到源点距离最小的顶点
Vertex FindMinIndex(Table T[], int n)
{
    ;
    int min = Infinity;
    Vertex min_index = NotVertex;
    ; i <= n; i++)
    {
        if (!T[i].known && T[i].dist < min)
        {
            min = T[i].dist;
            min_index = i;
        }
    }
    return min_index;
}

//下面是算法关键步骤啦  dijkstra算法
void Dijkstra(Table T[], int n, Vertex source)//source源点 顶点数n
{
    ;
    T[source].dist = ;//源点到源点的距离为0
    T[source].known = true;//源点已知

    //在做循环处理前 还要赋值给能直接到达源点的顶点的dist数据
    VerNode * ptemp;//能直接到达源点的顶点
    ptemp = T[source].header.pNext;
    Vertex w;
    while (ptemp)
    {
        w = ptemp->ver;
        T[w].dist = ptemp->weight;
        T[w].path = source;
        ptemp = ptemp->pNext;
    }

    Vertex v;
    //处理n-1个顶点
    ; i <= n-;i++)
    {
        //找出到源点距离最小的顶点
        v = FindMinIndex(T, n);
        if (v == NotVertex)
            break;
        T[v].known = true;
        ptemp = T[v].header.pNext;//找出顶点V所能到的顶点看是否能跟新他们的dist
        while (ptemp)
        {
            w = ptemp->ver;
            if (!T[w].known && T[w].dist > ptemp->weight + T[v].dist)//进行跟新操作
            {
                T[w].dist = ptemp->weight + T[v].dist;
                T[w].path = v;
            }
            ptemp = ptemp->pNext;
        }
    }
}

//下面输出我们的最短路径吧
void PrintPath(Table T[],Vertex v)
{
    if (T[v].path != NotVertex)
    {
        PrintPath(T, T[v].path);
        cout << " ---> ";
    }
    cout << v;
}

int main()
{
    Vertex v;
    InitTable(T, , );
    Dijkstra(T, , );
    cout << "源点1到各个顶点的最短路径如下:" << endl;
    ; v <= ; v++)
    {
        PrintPath(T, v);
        cout << endl;
    }
    system("pause");
    ;
}

运行结果

需要其他的信息可以根据需要输出

修改补充后的:SakuraOne Dijkstra单源最短路径算法


  THOUGHTS

    算法思想好理解  实现的话也挺好理解  但是关键就是理解的程度

    学习嘛 就是不断重复的过程 对想想就对了还有多动手画画

  

Dijkstra——单源最短路径的更多相关文章

  1. Dijkstra 单源最短路径算法

    Dijkstra 算法是一种用于计算带权有向图中单源最短路径(SSSP:Single-Source Shortest Path)的算法,由计算机科学家 Edsger Dijkstra 于 1956 年 ...

  2. Dijkstra单源最短路径,POJ(2387)

    题目链接:http://poj.org/problem?id=2387 Dijkstra算法: //求某一点(源点)到另一点的最短路,算法其实也和源点到所有点的时间复杂度一样,O(n^2); 图G(V ...

  3. 【模板 && 拓扑】 Dijkstra 单源最短路径算法

    话不多说上代码 链式前向星233 #include<bits/stdc++.h> using namespace std; ,_max=0x3fffffff; //链式前向星 struct ...

  4. Bellman-Ford 单源最短路径算法

    Bellman-Ford 算法是一种用于计算带权有向图中单源最短路径(SSSP:Single-Source Shortest Path)的算法.该算法由 Richard Bellman 和 Leste ...

  5. 单源最短路径算法---Dijkstra

    Dijkstra算法树解决有向图G=(V,E)上带权的单源最短路径问题,但是要求所有边的权值非负. 解题思路: V表示有向图的所有顶点集合,S表示那么一些顶点结合,从源点s到该集合中的顶点的最终最短路 ...

  6. Til the Cows Come Home(poj 2387 Dijkstra算法(单源最短路径))

    Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 32824   Accepted: 11098 Description Bes ...

  7. 单源最短路径——dijkstra算法

    dijkstra算法与prim算法的区别   1.先说说prim算法的思想: 众所周知,prim算法是一个最小生成树算法,它运用的是贪心原理(在这里不再证明),设置两个点集合,一个集合为要求的生成树的 ...

  8. 【转】Dijkstra算法(单源最短路径)

    原文:http://www.cnblogs.com/dolphin0520/archive/2011/08/26/2155202.html 单源最短路径问题,即在图中求出给定顶点到其它任一顶点的最短路 ...

  9. 图论(四)------非负权有向图的单源最短路径问题,Dijkstra算法

    Dijkstra算法解决了有向图G=(V,E)上带权的单源最短路径问题,但要求所有边的权值非负. Dijkstra算法是贪婪算法的一个很好的例子.设置一顶点集合S,从源点s到集合中的顶点的最终最短路径 ...

随机推荐

  1. 第45章:MongoDB-集群--Sharding(分片)--分片的管理

    ①列出所有的Shard db.runCommand({“listshards”:1}); ②查看分片信息 db.printShardingStatus(); ③判断是否分片 db.runCommand ...

  2. B树/[oracle]connect BY语句

    读大神的书,出现很多没有见过的函数和便捷操作,特此记录 connect by 之前没有接触过,为了学习这个语句,先了解一下B树数据类型是最好的方法. [本人摘自以下博客] https://www.cn ...

  3. 微信二次开发点击菜单openId的获取

    首先普及一个知识:一个关注的用户对于一个微信公众号是唯一的,也就是说一个用户针对与一个微信公众号是唯一的,对于不同的公众号,同一个微信号具有不同的openId; 在微信开发中,我们添加了一个二级菜单并 ...

  4. vscode调试golang环境搭建及配置

    准备VSCode 在官网下载最新版的VSCode: 安装Golang插件 打开扩展面板 VSCode->查看->扩展 找到Go插件 在搜索框里输入Go, 找到第二行写有 Rich Go l ...

  5. git无法同步

    出现问题: fatal: destination path 'test' already exists and is not an empty directory. 解决方法如下: git init ...

  6. why microsoft named their cloud service Azure?

    best guess I can personally make is that because Azure literally means “bright blue color of the clo ...

  7. Javascript高级编程学习笔记(80)—— 表单(8)表单序列化

    表单序列化 随着 Ajax 的出现,表单序列化成为一种常见需求 以将表单信息序列化为查询字符串为例 我们可以利用表单的 type 属性,以及 name 和 value 实现对表单的序列化 序列化应满足 ...

  8. Tomcat 的 server.xml 文件详解

    文件内容解读 <?xml version="1.0" encoding="UTF-8"?> <!-- Licensed to the Apac ...

  9. HTTP 协议服务器相关概念

    1.HTTP/1.1规范允许一台HTTP服务器搭建多个Web站点,即物理层面只有一台服务器,使用虚拟主机功能,可就假想有多台服务器. 在相同IP地址下,由于虚拟主机可以寄存多个不同主机名和域名的网站, ...

  10. 第50节:Java的当中的泛型

    Java当中的泛型 01 import java.util.ArrayList; import java.util.List; public class Demo{ public static voi ...