Dijkstra算法.

最新推荐文章于 2019-03-21 21:36:48 发布
最新推荐文章于 2019-03-21 21:36:48 发布
阅读量105 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： python 数据结构与算法
原文链接：https://my.oschina.net/SHIHUAMarryMe/blog/607688

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

#include <iostream>
#include <queue>
#include <map>
#include <stdexcept>//用于抛出异常.
#include <initializer_list> //std::initializer_list
namespace{ //用命名空间还是好的，防止命名污染. 
 static int MAXVALUE = 999;
}
template<typename T>
struct Node{
 T node_;
 int weighting_; //weighting_设置的是当前结点到给定源结点的所有的加权值的和默认都被设置为::MAXVALUE. 
 
 using node_type = T;
 
 Node()=default;
 
 template<typename Ty>
 Node(const Ty& node, const int& weighting=0); //构造函数. 
 
 template<typename Ty>
 Node(Node<Ty>&& otherNode); //移动构造函数.
 
 Node(const Node<T>& otherNode); //拷贝构造函数.
 
 Node<T>& operator=(const Node<T>& otherNode); 
 
 template<typename Ty>
 friend bool operator<(const Node<Ty>& first_, const Node<Ty>& second);
 
 template<typename Ty>
 friend bool operator==(const Node<Ty>& first_, const Node<Ty>& second_);
 
 template<typename Ty>
 friend std::ostream& operator<<(std::ostream& os, const Node<Ty>& node_);
 
 ~Node()=default;//注意这里只是设置了默认构造函数 
};
template<typename T>
template<typename Ty>
Node<T>::Node(const Ty& node, const int& weighting)
        :node_(node),
         weighting_(weighting)
{
 //
}
template<typename T>
template<typename Ty>
Node<T>::Node(Node<Ty>&& otherNode)
        :node_(otherNode.node_),
         weighting_(otherNode.weighting_)
{
 //
 std::cout<<"move-constructor"<<std::endl;
}
template<typename T>
Node<T>& Node<T>::operator=(const Node<T>& otherNode)
{
 this->node_ = otherNode.node_;
 this->weighting_ = otherNode.weighting_;
 
 //std::cout<<"operator="<<std::endl;
 return *this;
}
template<typename T>
Node<T>::Node(const Node<T>& otherNode)
        :node_(otherNode.node_),
         weighting_(otherNode.weighting_)
{
 //std::cout<<"copy for constructing"<<std::endl;
}
template<typename Ty>
bool operator<(const Node<Ty>& first_, const Node<Ty>& second_) //注意这里因为std::map是有序的切不重复容器. 
{
 return (first_.node_ < second_.node_) ? true : false;
}
template<typename Ty>
bool operator==(const Node<Ty>& first_, const Node<Ty>& second_)
{
 return (first_.node_ == second_.node_) ? true : false;
}
template<typename Ty>
std::ostream& operator<<(std::ostream& os, const Node<Ty>& node_){
 os<<node_.node_;
 return os;
}
class Compare{
 public:
  
  template<typename Ty>
  bool operator()(const Node<Ty>& first_, const Node<Ty>& second_);
};
template<typename Ty>
bool Compare::operator()(const Node<Ty>& first_, const Node<Ty>& second_)
{
 return first_ < second_;
}
template<typename T>
class Graph{ //所有边的加权值必须为正. 
 private:
  std::map<Node<T>, std::map<Node<T>, int>> edges_; //存储无向图的各个边的加权值. 
  std::map<Node<T>, std::vector<Node<T>>> adjList_; //每个结点所相接的结点的邻接链表.  
  std::map<Node<T>, bool> sourceArray_; //判断该点是否已经被放到了verticeArry_中. 
  std::map<Node<T>, int> dist_; //源结点到每个结点的距离. 
  
  std::map<Node<T>, Node<T>> node_to_node_;
  
  
  template<typename Ty>
  void initializer_distance(const Node<Ty>& source_)noexcept;
  
  public:
   template<typename Ty, unsigned int N>
   Graph(const Ty (&edges)[N][3]); 
   
   template<typename Ty>
   void Dijstra(const Ty& node_data);//Dijstra算法. 
   
   void print()const noexcept;
   
   ~Graph();
};
template<typename T>
template<typename Ty, unsigned int N>
Graph<T>::Graph(const Ty (&edges)[N][3])
{
 if(N == 0){
  std::runtime_error("There is nothing in Graph.\n");
 }
 
 for(int i=0; i<N; ++i){
  Node<Ty> first_(edges[i][0], ::MAXVALUE);//这里之所以用::因为MAXVALUE位于匿名的namespace中.
  Node<Ty> second_(edges[i][1], ::MAXVALUE);//每个结点当前的加权值被设置为MAXVALUE. 
  Node<Ty> temp_first_(edges[i][0], ::MAXVALUE);
  
  if(edges[i][2] < 0){
   throw std::runtime_error(std::string("The weighting must be bigger than 0"));
  }
  
   
  this->adjList_[first_].push_back(second_); //邻接链表. 
  
  this->dist_[first_] = ::MAXVALUE;
  this->dist_[second_] = ::MAXVALUE;
  
  this->sourceArray_[first_] = false;
  this->sourceArray_[second_] = false;
  
  for(int j=0; j<N; ++j){ //注意下面这几行这是为了构造一个结点的矩阵. 即每个结点与其他结点的之间的权重. 
   Node<Ty> temp_second_(edges[j][0], ::MAXVALUE);
   
   if(temp_first_ == temp_second_){
    this->edges_[temp_first_][temp_second_] = 0;
    continue;
   }
   
   this->edges_[temp_first_][temp_second_] = ::MAXVALUE;
  }
  
  this->edges_[first_][second_] = edges[i][2];
  
 }
  
 std::cout<<"out of constructor."<<std::endl;
}
template<typename T>
template<typename Ty>
void Graph<T>::Dijstra(const Ty& node_data)
{
 std::cout<<"enter dijstra"<<std::endl;
  
  
  Node<Ty> source(node_data);
  int node_number = this->adjList_.size();
  
  this->initializer_distance(source); //获得从source到与source相接的结点的值.
  
  for(int i=1; i<node_number; ++i){ //给定的图中一共有node_number个结点. 除去自身因此只需要循环node_number-1次. 
   Node<Ty> temp_node = source;
   int temp_distance = ::MAXVALUE;
   
   typename std::map<Node<Ty>, std::vector<Node<Ty>>>::const_iterator iter_first_ = this->adjList_.cbegin();
   for(; iter_first_ != this->adjList_.cend(); ++iter_first_){ //这个循环访问图中的每一个结点与给定的源结点 保存当前邻接点中距离最小的一个结点. 
    
    if(this->sourceArray_[iter_first_->first] == false && this->dist_[iter_first_->first] < ::MAXVALUE){
     temp_node = iter_first_->first;
     temp_distance = this->dist_[iter_first_->first];
    }
    
   }
   
   this->sourceArray_[temp_node] = true; //把已经找到的结点标记为true,标明已经访问过了. 
   
   //松弛操作. 
   typename std::map<Node<Ty>, std::vector<Node<Ty>>>::const_iterator iter_second_ = this->adjList_.cbegin();
   for(; iter_second_ != this->adjList_.cend(); ++iter_second_){ //利用松弛操作，更新temp_node与其他各个结点之间权重. 
    
    if(this->sourceArray_[iter_second_->first] == false && this->edges_[temp_node][iter_second_->first] < ::MAXVALUE){
     
     if(this->dist_[temp_node] + this->edges_[temp_node][iter_second_->first] < this->dist_[iter_second_->first]){
      this->dist_[iter_second_->first] = this->dist_[temp_node] + this->edges_[temp_node][iter_second_->first];
      this->node_to_node_[iter_second_->first] = temp_node;
     }
    }
   }
  }
  
  
}
template<typename T>
template<typename Ty>
void Graph<T>::initializer_distance(const Node<Ty>& source_)noexcept
{
 typename std::vector<Node<Ty>>::const_iterator iter_ = this->adjList_[source_].cbegin();
 for(; iter_ != this->adjList_[source_].cend(); ++iter_){ //dist_记录从source_到图中每个结点的距离.如果这两个结点没有相连接或者只有单向连接那么距离先被设置为::MAXVALUE; 
  
  this->dist_[*iter_] = this->edges_[source_][*iter_];
  this->node_to_node_[*iter_] = source_; //把邻接source的结点都放到node_to_node中. 
 }
 
 this->dist_[source_] = 0;
 this->sourceArray_[source_] = true;
 
}
template<typename T>
Graph<T>::~Graph()
{
 if(!this->edges_.empty()){
  this->edges_.clear();
 }
 
 if(!this->adjList_.empty()){
  typename std::map<Node<T>, std::vector<Node<T>>>::iterator iter = this->adjList_.begin();
  
  for(; iter!=this->adjList_.end(); ++iter){
   iter->second.clear();
  }
  
  this->adjList_.clear();
 }
 
 if(!this->sourceArray_.empty()){
  this->sourceArray_.clear();
 }
 
 if(!this->dist_.empty()){
  this->dist_.clear();
 }
 
 if(!this->node_to_node_.empty()){
  this->node_to_node_.clear();
 }
}
template<typename T>
void Graph<T>::print()const noexcept
{
 typename std::map<Node<T>, Node<T>>::const_iterator iter = this->node_to_node_.cbegin();
 
 for(; iter != this->node_to_node_.cend(); ++iter){
  std::cout<<iter->first<<"    "<<iter->second<<std::endl;
 }
}
int main()
{
 int undirectedGraph[9][3]={ {1, 6, 14}, {1, 3, 9}, {2, 3, 10}, {2, 4, 15}, {3, 6, 2}, {3, 4, 11}, {4, 5, 6}, {5, 6, 9}, {6, 9, 5} };
 Graph<int> myGraph(undirectedGraph);
 myGraph.Dijstra(1);
 
 myGraph.print();
 
 return 0;
}

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/607688

基于MATLAB的dijkstra算法及其应用
wenyusuran的专栏
05-19 5132
简介 dijkstra算法（迪杰斯特拉算法）是一种经典的优化算法。以其应用的广泛性与简便性，值得我们去研究。 Dijkstra算法是典型最短路算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。（摘自网络，呵呵） 实例 这里给出一个基于MATLAB的di
dijstra算法matlab源程序代码
11-26
dijstra算法matlab源程序代码，直接复制进matlab，建立矩阵就可以了
最短路径模板 Dijstra算法
蒟篛小渣渣
03-21 321
一、算法实现 二、代码实现 #include<cstdio> #include<cstring> #include <queue> const int sizeM = 500005; const int sizeN = 10005; using namespace std; int n,m,s,cnt; int head[sizeN],dis[sizeN],vi...
最短路径之dijstra算法
weixin_30692143的博客
02-09 146
Dijkstra算法图文详解：https://blog.csdn.net/lbperfect123/article/details/84281300 动画演示https://www.cnblogs.com/kex1n/p/4178782.html dijkstra算法---通过边实现松弛 : https://www.cnblogs.com/dailinfu/p/7398112....
Dijkstra算法（最短路）的可视化实现
05-26
用windows界面实现了最短路问题的Dijstra算法，感觉程序功能还可以。
用Dijstra算法求解2007高教社杯全国大学生数学建模B题
Anson_Lang的博客
07-25 6603
B题：乘公交，看奥运       我国人民翘首企盼的第29届奥运会明年8月将在北京举行，届时有大量观众到现场观看奥运比赛，其中大部分人将会乘坐公共交通工具（简称公交，包括公汽、地铁等）出行。这些年来，城市的公交系统有了很大发展，北京市的公交线路已达800条以上，使得公众的出行更加通畅、便利，但同时也面临多条线路的选择问题。针对市场需求，某公司准备研制开发一个解决公交线路选择问题的自主查询计算机
基于Matlab实现Dijkstra算法.zip
11-22
由于该压缩包的标题和描述中提到“基于Matlab实现Dijkstra算法.zip”，我们可以推断该文件中包含了完整的Matlab代码，旨在通过Matlab编程实践来展示Dijkstra算法的实现过程。此外，描述中还提到了“shell脚本编程...
dijkstra算法.docx
06-29
### Dijkstra算法详解 #### 算法背景与定义 Dijkstra算法是由荷兰计算机科学家Edsger W. Dijkstra在1956年提出的，它主要用于解决加权图中的单源最短路径问题。该算法适用于带有非负权重边的有向图或无向图，并且是...
最短路径Dijkstra算法.pptx
04-29
Dijkstra算法是最著名的解决单源最短路径问题的算法，它适用于无负权边的图。算法的基本思路是通过不断选择未访问顶点中距离源点最近的顶点，并逐步扩展其邻接顶点的最短路径估计。 Dijkstra算法的步骤可以概括为...
2025年Dijkstra算法.doc
最新发布
05-03
Dijkstra算法是一种被广泛使用的图论算法，它能够解决单源最短路径问题。该算法由荷兰计算机科学家Edsger W. Dijkstra于1956年提出，并在1959年发表。Dijkstra算法可以应用于带权有向图中，用于计算图中某个节点...
dijkstra算法求两点之间最短路径
zygzzp的专栏
11-08 7194
http://blog.csdn.net/winbobob/article/details/38272679 Floyd-Warshall算法十字交叉法package com.geo.xiaojinku.udf.utils; import java.util.LinkedHashMap; import java.util.Map; import java.util.Map.Entry; im
Dijkstra算法以及java实现_02（代码部分）
胡倩萌的博客
06-17 1689
1.数据库表的设计： dijsname1和dijsname2是有向图中的两个点。 qinmid是这两个点之间的亲密度，将亲密度的值作为边的权值大小。2.对数据库中数据进行增删改查操作：//这里主要实现了insert(插入)操作和查找操作(通过两个点查找亲密度) package com.graduat.dao.impl; public class DijstraImpl implements Dij
温习 数据结构之求最短路径 Dijstra
weixin_34221775的博客
01-08 172
#include &lt;stdio.h&gt; #define INFINITY INT_MAX //最大值 #define MAX_VERTEX_NUM 20 //最大顶点个数 #define MAX_NAME 5 //定点字符串的最大长度+1 #define MAX_INFO 20 //相关信息字符串的最大长度+1 #define FALSE 0 #def...
迪克斯特拉（Dijkstra）算法之MATLAB实现
热门推荐
Virgo的博客
01-12 10万+
by WC 1.12.2016 1. 迪克斯特拉（Dijkstra）算法 在网上面看了很多的解释，仍没有感觉到有非常通熟易懂的解释，在这里我为大家讲解一下，尽量避免枯燥难懂的数学公式。 狄克斯特拉算法。是从一个特定的顶点（又可称为原点，可自己定义）到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。举个例子，通熟
Dijkstra算法及其matlab实现
09-05 2万+
目录 图的概念 图的分类 图的矩阵表示 最短路问题和Dijkstra算法 图的概念 图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。 一个图可以用数学语言描述为G(V(G),E(G))。V(vertex)指的是图的顶点集，E(edge)指的是图的边集。一个...
最短路径Dijkstra算法原理及Matlab实现
capoziom的博客
08-20 9万+
图论的基础知识不再阐述。 最短路径算法主要有二 Dijkstra算法 Floyd算法 Dijkstra算法研究的是从初始点到其他每一结点的最短路径 而Floyd算法研究的是任意两结点之间的最短路径 以下图为例，首先介绍Dijstra的原理 红字为各结点的编号，蓝字为各结点之间的距离 首先定义几个变量 结点个数n； 二维矩阵M（nxn），距离矩阵，连通的结点间即为距离，不...
【最短路】求任意两点间最短路径的改进的Dijkstra算法及其matlab实现
weixin_30446613的博客
09-04 1140
代码来源：《图论算法及其matlab实现》（北京航空航天出版社） P18 书中提出了基于经典Dijkstra算法改进的两种算法。 其中算法Ⅱ的效率较高。 代码如下： 1 function a=Dijk(a) 2 %a(输入量)表示图的邻接矩阵 3 %a(输出量)表示所求最短路径的距离矩阵 4 5 %建立邻接矩阵，若不还是对称矩阵，则变为对称矩阵 ...
最短路径dijkstra算法精品代码（超详解）
KING_阿飞的博客
08-13 3万+
一：简介 　　这个算法用于解决图中单源最短路径问题。所谓单源节点是指给定源节点，求图中其它节点到此源节点的最短路径。如下图所示：给定源节点a，求节点b到a的最短距离。 (图来自于参考资料2) 那么如何寻找？还是以上图为例： 1）初始化：设定除源节点以外的其它所有节点到源节点的距离为INFINITE(一个很大的数)，且这些节点都没被处理过。 ...
Dijkstra算法实现最短路径代码解析
资源摘要信息:"Dijkstra算法.zip_dijkstra_dijkstra算法" 知识点: Dijkstra算法是一种用于在加权图中找到最短路径的算法，由荷兰计算机科学家艾兹赫尔·戴克斯特拉（Edsger W. Dijkstra）于1956年提出，并于1959年...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值