Johnson算法

最新推荐文章于 2024-09-24 23:16:50 发布
最新推荐文章于 2024-09-24 23:16:50 发布
阅读量225 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： python 数据结构与算法
原文链接：https://my.oschina.net/SHIHUAMarryMe/blog/636440

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

#include <iostream>
#include <map>
#include <vector>
#include <stdexcept>
#include <memory>
namespace{
 enum : int{
  MAXVALUE = 9999;
 };
}
template<typename T>
class Node{
 public:
  T key_;
  
  template<typename Ty>
  Node(const T& key);
  
  Node()=default;
  
  Node(const Node<T>& otherNode_);
  
  template<typename Ty>
  Node(Node<Ty>&& otherNode_);
  
  template<typename Ty>
  Node(Node<Ty>* node_ptr_);
  
  const Node<T>& operator=(const Node<T>& otherNode_);
  
  template<typename Ty>
  const Node<Ty>& operator=(Node<Ty>&& 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_);
  
  ~Node()=default;
  
  using node_type = T;
};
template<typename T>
template<typename Ty>
Node<T>::Node(const Ty& key)
        :key_(key)
{
 //default constructor.
}
template<typename T>
Node<T>::Node(const Node<T>& otherNode_)
        :key_(otherNode_.key_)
{
 //copy-constructor.
}
template<typename T>
template<typename Ty>
Node<T>::Node(Node<Ty>&& otherNode_)
        :key_(otherNode_.key_)
{
 //move-constructor.
}
template<typename T>
template<typename Ty>
Node<T>::Node(const Node<Ty>* node_ptr_)
        :key_(node_ptr_.key_)
{
 //
}
template<typename T>
const Node<T>& Node<T>::operator=(const Node<T>& otherNode_)
{
 this->key_ = otherNode_.key_;
 
 return *this;
}
template<typename T>
template<typename Ty>
const Node<Ty>& Node<T>::operator=(Node<Ty>&& otherNode_)
{
 this->key_ = otherNode_.key_;
 
 return *this;
}
template<typename Ty>
bool operator<(const Node<Ty>& first_, const Node<Ty>& second_)
{
 return (first_.key_ < second_.key_) ? true : false;
}
template<typename Ty>
bool operator==(const Node<Ty>& first_, const Node<Ty>& second_)
{
 return (first_.key_ == second_.key_) ? true : false;
}
template<typename T>
class Graph{
 private:
  std::map<Node<T>, std::map<Node<T>, int>> graph_; //存储有向图.在下面的构造函数中会把新结点(默认为0)加入进去。  
  std::map<Node<T>, int> distance_; //保存从给定顶点到各个顶点所经过的路程. 
  std::map<Node<T>, std::vector<Node<T>>> adjList_;
  
  std::map<Node<T>, bool> whether_visited_;  //用于dijstra算法. 判断当前结点是否被访问过,默认都为false. 
  std::vector<Node<T>> have_find_; //用于dijstra算法. 存放已经找到最短路径的结点. 
  std::map<Node<T>, Node<T>> node_to_node_;
  
  std::map<Node<T>, std::vector<Edge<T>>> one_for_all_; //当Node<T>作为源结点的时候，对应的有向图中源结点到各个结点的距离. 
  
  unsigned int node_number_;
  T source_key_;
  bool flag_;  //如果给定的有向图中存在负环路,那么flag_为true,否则为false.(默认为false). 
  
  template<typename Ty>
  void bellman_ford(const Ty& source_data); //之所以使用Bellman-ford算法是因为该算法允许存在权重为负数的边. 
  
  void initialize_single_source()noexcept;
  
  template<typename Ty>
  void relax(const Node<Ty>& first_, const Node<Ty>& second_)noexcept;
  
  template<typename Ty>
  void dijstra_algorithm(const Node<Ty>& node_)noexcept;
  
  template<typename Ty>
  void initialized_distance(const Node<Ty>& source_)noexcept;
  
  template<typename Ty>
  void relax_dijstra(const Node<Ty>& first_, const Node<Ty>& second_)noexcept;
  
  void transition()noexcept; //这是一个过渡函数用于bellman-ford算法结束后和Dijstra算法开始前.
  //其主要用于在bellman-ford算法执行结束后求得给定的源节点(source)到图中各个结点间的最短路径后把这些路径更新到graph_中. 
  
  template<typename Ty>
  void helper_function(const Node<Ty>& node_)noexcept;
  
  template<typename edge_type>
  class Edge{
   public:
   std::shared_ptr<Node<edge_type>> start_;
   std::shared_ptr<Node<edge_type>> end_;
   int weighting_; //该边的加权值.
   
   Edge()=default;
   
   template<typename Ty>
   Edge(const Ty& start, const Ty& end_);
   
   template<typename Ty>
   Edge(const Node<Ty>& first_, const Node<Ty>& second_);
   
   Edge(cosnt Edge<T>& otherEdge_);
   
   template<typename Ty>
   Edge(Edge<Ty>&& otherEdge_);
   
   const Edge<edge_type>& operator=(const Edge<edge_type>& otherEdge_);
   
   template<typename Ty>
   const Edge<Ty>& operator=(Edge<Ty>&& otherEdge_);
   
   ~Edge()=default;
  };
  
  public:
   using map_iter = typename std::map<Node<T>, int>::const_iterator;
   
   using map_in_map_iter = typename std::map<Node<T>, std::map<Node<T>, int>>::const_iterator;
   
   using vec_iter = typename std::vector<Node<T>>::const_iterator;
   
   using mapVec_iter = typename std::map<Node<T>, std::vector<Node<T>>>::const_iterator;
   
   template<typename Ty, unsigned int N>
   Graph(const Ty (&edges)[N][3]);
   
   Graph()=default;
   
   template<typename Ty>
   void johnson_algorithm(const Ty& source_);
   
   ~Graph();
};
template<typename T>
template<typename edge_type>
template<typename Ty>
Graph<T>::Edge<edge_type>::Edge(const Ty& start, const Ty& end)
                          :Edge(Node<Ty>(start), Node<Ty>(end))
{
 //the constructor of edge;
}
template<typename T>
template<typename edge_type>
template<typename Ty>
Graph<T>::Edge<edge_type>::Edge(const Node<Ty>& first_, const Node<Ty>& second_)
                          :start_(std::make_shared<Node<Ty>>(Node<Ty>(first_))),
                           end_(std::make_shared<Node<Ty>>(Node<Ty>(second_)))
{
 //
}
 
template<typename T>
template<typename edge_type>
Graph<T>::Edge<edge_type>::Edge(const Edge<edge_type>& otherEdge_)
                          :start_(otherEdge_.start_),
                           end_(otherEdge_.end_),
                           weighting_(0)
{
 //copy-constructor for edge;
}
template<typename T>
template<typename edge_type>
template<typename Ty>
Graph<T>::Edge<edge_type>::Edge(Edge<Ty>&& otherEdge_)
                          :start_(otherEdge_.start_),
                           end_(otherEdge_.end_),
                           weighting_(otherEdge_.weighting_)
{
 otherEdge_.start_.reset();
 otherEdge.end_.reset();
 
 //move-constructor for edge;
}
template<typename T>
template<typename edge_type>
const Edge<edge_type>& Graph<T>::Edge<edge_type>::operator=(const Edge<edge_type>& otherEdge_)
{
 this->start_ = otherEdge_.start_;
 this->end_ = otherEdge_.end_;
 this->weighting_ = otherEdge_.weighting_;
 
 return *this;
 //operator=;
}
template<typename T>
template<typename edge_type>
template<typename Ty>
const Edge<Ty>& Graph<T>::Edge<edge_type>::operator=(Edge<Ty>&& otherEdge_)
{
 this->start_ = otherEdge_.start_;
 this->end_ = otherEdge_.end_;
 this->weighting_ = otherEdge_.weighting_;
 
 otherEdge_.start_.reset();
 otherEdge_.end_.reset();
 
 return *this;
}
template<typename T>
template<typename Ty, unsigned int N>
Graph<T>::Graph(const Ty (&edges)[N][3])
         :node_number_(N),//注意这里的node_number_ = N;
          flag_(false)
{
 if(N == 0){
  throw std::runtime_error(std::string("there is nothing in graph"));
 }
 
 Node<Ty> temp_node(0); //temp_node作为我们新加入的结点. 
 
 //存储有向图. 
 //同时新建一个结点(temp_node)该结点与图中其他结点的之间的加权值为0. 
 for(int i=0; i<N; ++i){
  Node<Ty> first_(edges[i][0]);
  Node<Ty> second_(edges[i][1]);
  
  for(int j=0; j<N; ++j){
   Node<Ty> third_(edges[i][0]);
   
   if(first_ == third_){
    this->graph_[first_][third_] = 0;
    continue;
   }
   
   this->graph_[first_][third_] = ::MAXVALUE;
  } 
  
  this->graph_[first_][second_] = edges[i][2];
  this->graph_[temp_node][first_] = 0;
  this->graph_[temp_node][second_] = 0;
  
  
  
  this->distance_.insert(std::pair<Node<Ty>, int>(first_, ::MAXVALUE));
  this->distance_.insert(std::pair<Node<Ty>, int>(second_, ::MAXVALUE));
  
  this->adjList_[first_].push_back(second_); //每个结点的邻接链表. 
  
  this->whether_visited_[first_] = false;
  this->whether_visited_[second_] = false;
 }
 
 this->whether_visited_[temp_node] = false;
 this->distance_.insert(std::pair<Node<Ty>, int>(temp_node, 0));
 
 
 std::cout<<"construct a graph successfully!"<<std::endl;
 
}
template<typename Ty>
void Graph<T>::initialize_single_source()noexcept
{
 Node<T> source_node(this->source_key_);
 this->distance_[source_node] = 0; //把源结点距离自己的距离初始化为0. 
}
template<typename T>
template<typename Ty>
void Graph<T>::bellman_ford(const Ty& source_data) //通过Bellman-ford算法求出 新加入的结点到各个结点的最短距离. 
{
 this->source_key_ = source_data;
 this->initialize_single_source();
 
 for(int 1=0; i<this->node_number_; ++i){ //注意这里的node_number_是N(N代表原图中结点的个数我们新加入的那个结点的是没有被算进去的). 
  
  mapVec_iter iter_first_ = this->adjList_.cbegin();
  for(; iter_first_ != this->adjList_.cend(); ++iter_first_){
   
   vec_iter iter_second_ = this->adjList_[iter_first_->first].cbegin();
   for(; iter_second_ != this->adjList_[iter_first_->first].cend(); ++iter_second_){
    this->relax(iter_first_->first, *iter_second);
   }
  }
 }
 
 mapVec_iter iter_third_ = this->adjList_.cbegin();
 for(; iter_third_ != this->adjList_.cend(); ++iter_third_){ //判断是否存在负环路. 
  
  vec_iter iter_forth_ = this->adjList_[iter_third_->first].cbegin();
  for(; iter_forth_ != this->adjList_[iter_third_->first].cend(); ++iter_forth_){
   
   if(this->distance_[*iter_forth_] > this->distance_[*iter_third_] + this->graph_[iter_third_->first][*iter_forth]){
    this->flag_ = true; //设为true表明存在负回路. 
    break;
   }
  }
  
  if(this->flag_){
   break;
  }
 }
 
}
template<typename T>
template<typename Ty>
void Graph<T>::relax(const Node<Ty>& first_, const Node<Ty>& second_)
{
 if(this->distance_[second_] > this->distance_[first_] + this->graph_[first_][second_]){
  this->distance_[second_] = this->distance_[first_] + this->graph_[first_][second_];
 }
}
template<typename T>
void Graph<T>::transition()noexcept
{
 Node<T> source_node(this->source_key_);
 map_iter iter = this->distance_.cbegin();
 for(; iter != this->distance_.cend(); ++iter){
  this->graph_[source_node][iter->first] = this->distance_[iter->first];
 }
}
template<typename T>
template<typename Ty>
void Graph<T>::dijstra_algorithm(const Node<Ty>& node_)noexcept
{
 //注意这个+1，因为node_number_在初始化的时候被赋值为N.（N是不包含给定的源结点的,源结点是我们自己给出的不同于图中任何一个结点）. 
 for(int i=1; i<this->node_number_+1; ++i){
  Node<T> temp_node = node_;
  int temp_weighting = ::MAXVALUE;
  
  vec_iter iter_ = this->adjList_[source_node].cbegin();
  for(; iter_ != this->adjList_[source_node].cend(); ++iter_){
   
   if(this->whether_visited_[*iter_] == false && this->graph_[source_node][*iter_] < temp_weighting){
    temp_weighting = this->graph_[source_node][*iter_];
    temp_node = *iter_;
   }
  }
  
  this->whether_visited_[source_node] = true; //已经访问过的结点被设置为true.
  
  mapVec_iter iter_first_ = this->adjList_.cbegin();
  for(; iter_first_ != this->adjList_cend(); ++iter_first_){
   this->relax_dijstra(iter_first->first, temp_node);
  }
 }
}
template<typename T>
template<typename Ty>
void Graph<T>::relax_dijstra(const Node<Ty>& first_, const Node<Ty>& second_) //second----first想象成一条边. 
{
 if(this->whether_visited_[first_] == false && this->graph_[second_][first_] < ::MAXVALUE){
  
  if(this->distance_[second_] + this->graph_[second_][first_] < this->distance_[first_]){
   this->distance_[first_] = this->distance_[second_] + this->graph_[second_][first_];
   
   this->node_to_node_[first_] = second_; //first结点的前驱结点为second_; 
  }
 }
}
template<typename T>
template<typename Ty>
void Graph<T>::johnson_algorithm(const Ty& source_)
{
 this->bellman_ford(0);
 if(this->flag_){
  throw std::runtime_error(std::string("There is negative-cycle in graph.\n"));
 }
 
 this->transiton(); //过渡函数. 
 
 mapVec_iter iter_first_ = this->adjList_.cbegin();
 for(; iter_first_ != this->adjList_.cend(); ++iter_first_){
  this->dijstra_algorithm(iter_first_->first);
  this->helper_function(iter_first_->first);
 }
}
template<typename T>
template<typename Ty>
void Graph<T>::helper_function(const Node<Ty>& node_)noexcept
{
 map_iter iter_first = this->distance_.cbegin();
 for(; iter_first != this->distance_.cend(); ++iter_first){
  Edge<Ty> temp_edge(node_, iter_first->first);
  temp_edge.weighting = iter_first->second;
  this->one_to_all_[node_].push_back(temp_edge);
 }
}

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

Johnson's Algorithm
lsxpu的专栏
04-26 2361
#ifndef DIJKSTRA_H #define DIJKSTRA_H #include #include #include using namespace std; typedef struct { int head; int tail; int cost; } Edge; void Dijkstra(vector &E, vector> &Vtail, int nV,
Johnson算法实现原理和优化策略
工宗浩生财指南针
05-09 968
边的重标定（Reweighting）：给图中的每一条边赋予一个新的权值，使得所有边的权值为非负。这可以通过Bellman-Ford算法实现，将每个顶点到源点的最短路径长度加到该顶点出发的每条边的权值上。使用Dijkstra算法：在重标定后的图中，对每个顶点运行Dijkstra算法，找到该顶点到图中所有其他顶点的最短路径。边权的恢复（Unreweighting）：将第二步中得到的最短路径中边的权值恢复到原始权值，以得到真实的最短路径。
Johnson 算法
billhu专栏
05-11 7748
  求解流水作业调度问题的 Johnson 算法具体描述如下： （1）       设 a[i] 和
（超简单、超易懂、超详细）算法精讲(二十三)：约翰逊算法
Malex2024的博客
06-23 2111
约翰逊算法（Johnson's algorithm）是一种用于解决作业调度问题的算法。作业调度问题是指给定一组作业，每个作业都有一个在两台机器上完成的时间，目标是找到一种调度顺序，使得完成所有作业所需的总时间最短。约翰逊算法的基本思想是将作业分成两个阶段进行调度。首先，通过对每个作业的机器1完成时间进行排序，将其调度在最前面。然后，在此基础上，通过对每个作业的机器2完成时间进行排序，将其调度在最后面。通过这种调度方式，约翰逊算法能够使得在机器1上的作业都尽早完成，并且在机器2上的作业都尽晚完成。
johnson算法
07-06
压缩包中的"johnson算法"文件可能包含了算法的具体实现代码、示例、或者是关于如何应用约翰逊算法的教程。对于初学者，阅读和理解这些内容可以帮助深入掌握约翰逊算法的工作原理，并且能够将其运用到实际问题中。...
《经典图论算法》约翰逊算法(Johnson)
最新发布
数据结构和算法
09-24 1875
摘要：1，约翰逊算法的介绍2，约翰逊算法的实现步骤3，约翰逊算法的准确性验证4，约翰逊算法的代码实现1，约翰逊算法的介绍约翰逊算法(Johnson algorithm)是在稀疏图上求每对顶点之间最短路径的一种算法，该算法在 1977 年由 Donald B. Johnson 提出。在前面我们讲过求任意两对顶点之间的最短路径可以使用《Floyd算法》，它可以解决有负权边的图，但不能有负权回路，它的时...
所有结点对的最短路径问题之Johnson算法
热门推荐
豆子的collection
01-05 1万+
Johnson算法可以在O(V*V lgV + VE)的时间内找到所有节点对之间的最短路径，对于稀疏图来说，算法的渐进表现要由于重复平方法和FloydWarshall算法，如果图没有权值为负值的环路，则返回所有结点对的最短路径权重的矩阵，否则，报告图有权值为负的环 算法中运用Diskra、BellmanFord算法，使用的技术是重新赋予权重， 如果图G = （V, E）中权值全为非负值，则通过
Johnson（流水作业调度的最优算法）
08-09
Johnson（流水作业调度的最优算法），算法思想基于动态规划，里面包含了公式的推导与poj例题的简单实现的代码
Java实现基于Johnson法则的流水作业调度
10-12
本压缩包中的文档参考《算法分析与设计》第三版 王晓东——动态规划一章完成，内含源代码，可供有兴趣的同学参考使用。
约翰逊算法
weixin_34090643的博客
07-08 2241
浅谈Johnson算法
Ajwallet
07-11 8432
在有向图的处理中，通常会遇到一个非常棘手的问题——那就是遇到负环，许多最短路算法例如Dij和Floyd都不可以处理负环（包括堆优化的），这个时候我们可以怎样处理呢？通常来说最常见的方法是使用能够处理负环的方法Bellman−Ford和基于其的Spfa，但是有人会问，可不可以不用这些呢，有！那就是Johnson
johnson算法 java_Java设计原则
weixin_42356315的博客
02-17 181
引用一段经典的话，“武学的最高境界是无招胜有招”，在编程领域，设计模式就可以认为是招数，而真正的内功心法是设计原则；下面讲述一下编程中应该遵循的基本原则1、单一职责原则一个类只负责一种职责，只有这种职责的改变会导致这个类的变更。绕口一点的正统说法：不要存在多于一个原因导致类变更假如：类T 负责有两种职责 P1，P2；当P1发生改变时，需要修改类T，这时候可能会对P2造成影响。所以不要为了图代码量少...
图论 —— 最短路 —— Johnson 算法
Alex_McAvoy的博客
10-07 2892
【概述】 对于单源最短路来说，有时间复杂度为 O(E+VlogV) 要求权值非负的 Dijkstra，时间复杂度为 O(VE) 适用于带负权值的Bellman Ford 对于全源最短路来说，除了时间复杂度为 O(V*V*V) 利用动态规划思想的 Floyd 算法外，可以认为是单源最短路径的推广，即分别以每个顶点为源点求其至其他顶点的最短距离 对于每个顶点利用 Ford 算法，时间复杂度为 ...
最短路—Johnson算法（解决负权边，判断负权环）
pursuit的博客
07-30 6950
最短路—Johnson算法（解决负权边，判断负权环）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值