有向网_最短路径_Dijkstra算法_Flody算法

最新推荐文章于 2023-02-20 15:46:00 发布
最新推荐文章于 2023-02-20 15:46:00 发布
阅读量3.4k 收藏 9
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构有向网 最短路径 Dijkstra算法 Flody算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37357063/article/details/82259086
版权

 

目录

1.求有向网的最短路径_Dijkstra算法_单源点最短路径问题

1.1建立有向网的邻接矩阵存储结构：

1.2Dijkstra算法

2.Flody算法：求有向网没对顶点之间的最短路径

1.求有向网的最短路径_Dijkstra算法_单源点最短路径问题

Dijkstra算法的关键思想：按路径长度递增的次序产生最短路径 ：下面的代码使用Final[]数组来体现按路径长度递增的顺序产生各条最短路径：

有向网G：表示为DN：Directed Network

G的顶点集合V，源点v0

从v0可达到的顶点（即终点）集合S，其他不可达（或在算法运算过程中暂时不可达）的顶点集合V-S

/*
    使用Dijkstra算法，
    求有向网DN的v0顶点到其余顶点v
    的最短路径P[v]以其带权路径长度D[v]
    v0是源点，求源点到图中其他顶点的最短路径

    DN的顶点集合V分为两个集合S  和  V-S
    从源点v0可到达的顶点集合S
    初始S={v0}
    S为已经找到的从源点v0出发的最短路径的终点集合


    P[v][w]为true表明：w是从v0到v当前求得最短路径上的顶点
    v0->v直达的就是起点v0和终点v

    Final[v]为true，当且仅当v属于S集合，表面当前已经求得的从v0到v的最短路径，
    中间过程不一定是最短，但至少表面v0到v可达

    */

 

 

1.1建立有向网的邻接矩阵存储结构：

#define INFINITY INT_MAX

typedef struct vexNode{
	int No;
}vexNode;

class DN{
private:
	//采用数组表示法，构造有向网
	int vexnum, arcnum;
	vector<vexNode*> vexNodePtrVec;
	vector<vector<int>> MG;
	/*路径矩阵P：PathMatrix
	P[v][w]为true则代表，则w是从源点v0到v的当前求得的最短路径上的顶点*/
	vector<vector<bool>> P;
	//final[v]为true代表，当且仅当v属于S，即已经求得从v0到v的最短路径终点
	vector<bool> Final;		
	/*最短路径记录列表D，
	记录源点v0到其他各个顶点的最短路径，D[v0]=0;
	若v0可达顶点i，则D[i]为v0->Vi的最短路径值；
	若v0不可达vi，则D[i]=INFINITE
	*/
	vector<int> D;


	/*
	法二：Flody算法：
	*/
	vector<vector<vector<bool> > > PathMatrix;
	vector<vector<int>> DistanceMatrix;

public:
    	DN(){
		CreateDN();
	}
	~DN(){}
	void CreateDN();
    void ShortPath_DIJ(int v0);
	void PrintResultDijkstra();
	/*
	法二：Flody算法：
	*/
	void ShortestPath_FLOYD();
	void PrintDistanceMatrixFLOYD();

}

    void DN::CreateDN()函数构造有向网：

void CreateDN()
	{
		cin >> vexnum >> arcnum;
		for (int i = 0; i < vexnum; i++)
		{
			vexNode* vexNodePtr = new vexNode;
			vexNodePtr->No = i;
			vexNodePtrVec.push_back(vexNodePtr);
			vector<int> rowVec1;
			vector<bool> rowVec2;
			for (int j = 0; j < vexnum; j++)
			{
				rowVec1.push_back(INFINITY);
				rowVec2.push_back(false);
			}
			MG.push_back(rowVec1);
			P.push_back(rowVec2);
			Final.push_back(false);
			D.push_back(INFINITY);

			vector<vector<bool>> PathMatrixDepth;
			vector<int> DistanceMatrixRow;
			for (int j = 0; j < vexnum; j++)
			{
				vector<bool> PathMatrixRow;
				for (int k = 0; k < vexnum; k++)
				{
					PathMatrixRow.push_back(false);
				}
				PathMatrixDepth.push_back(PathMatrixRow);
				DistanceMatrixRow.push_back(INFINITY);
			}

			PathMatrix.push_back(PathMatrixDepth);
			DistanceMatrix.push_back(DistanceMatrixRow);


		}
		int v1, v2, weight;
		for (int i = 0; i < arcnum; i++)
		{
			cin >> v1 >> v2 >> weight;
			MG[v1][v2] = weight;
		}
	}

1.2Dijkstra算法

求有向网的单源节点到其他各个顶点的最短路径：

	void ShortPath_DIJ(int v0)
	{//
	/*

	使用Dijkstra算法，
	求有向网DN的v0顶点到其余顶点v
	的最短路径P[v]以其带权路径长度D[v]
	v0是源点，求源点到图中其他顶点的最短路径

	DN的顶点集合V分为两个集合S  和  V-S
	从源点v0可到达的顶点集合S
	初始S={v0}
	S为已经找到的从源点v0出发的最短路径的终点集合


	P[v][w]为true表明：w是从v0到v当前求得最短路径上的顶点
	v0->v直达的就是起点v0和终点v

	Final[v]为true，当且仅当v属于S集合，表面当前已经求得的从v0到v的最短路径，
	中间过程不一定是最短，但至少表面v0到v可达

	*/

		for (int v = 0; v < vexnum; v++)
		{
			D[v] = MG[v0][v];//D[]的初始化，就是邻接表MG[v0][]上的的权值
			if (D[v] < INFINITY)
			{//D[v] < INFINITY说明v0可直达v，
				P[v][v0] = true;//路径起点的初始化：v0是从v0到v当前求得的最短路径上的顶点(起点初始化)
				P[v][v] = true;//终点初始化，v是从v0到v当前求得的最短路径上的顶点(终点初始化)
			}
		}
		D[v0] = 0;			//v0到v0的距离为0
		Final[v0] = true;	//集合S初始化，v0属于集合S
		//开始主循环，每次求得v0到某个顶点v的最短路径，并将v加入集合S
		for (int i = 0; i < vexnum; i++)
		{
			if (i == v0)
			{//除去v0的，其余的vexnum-1个顶点都遍历一遍
				continue;
			}
			else
			{
				int v = i;
				int min = INFINITY;//当前v0->v的最近距离
				for (int w = 0; w < vexnum; w++)
				{
					if (!Final[w])//w在集合V-S中
					{
						if (D[w] < min)
						{//在D向量中的属于V-S的集合中选择最小的分量
							v = w;
							min = D[w];
						}
					}
				}
				//这里的v是属于V-S集合的
				Final[v] = true;//将v加入到S集合
				//更新当前最短路径和距离
				for (int w = 0; w < vexnum; w++)
				{
					if (MG[v][w] == INFINITY)
					{//从v到w并没有路径
						continue;
					}
					else if (!Final[w] && (min + MG[v][w] < D[w]))
					{//w在集合V-S中，如果min + MG[v][w] < D[w]，将更新D[w]
						D[w] = min + MG[v][w];
						P[w] = P[v];
						P[w][w] = true;//更新终点：w是从v0到w当前求得最短路径上的终点
					}
				}
			}
		}
	}

2.Flody算法：求有向网没对顶点之间的最短路径

	/*
	法二：Flody算法：
	*/
	void ShortestPath_FLOYD()
	{
		/*
		Floyd算法求有向网G中各对顶点v和w之间的最短路径P[v][w]
		及其带权长度D[v][w]。
		若P[v][w][u]=true则表明：u是从v到w之间当前求得的最短路径上的顶点
		*/
		for (int v = 0; v < vexnum; v++)
		{
			for (int w = 0; w < vexnum; w++)
			{
				DistanceMatrix[v][w] = MG[v][w];
				if (DistanceMatrix[v][w] < INFINITY)
				{//从v到w有直达路径
					PathMatrix[v][w][v] = true;//从v->w的起点v路径标记初始化
					PathMatrix[v][w][w] = true;//从v->w的终点w路径标记初始化
				}
			}
			DistanceMatrix[v][v] = 0;
		}

		for (int u = 0; u < vexnum; u++)
		{
			for (int v = 0; v < vexnum; v++)
			{
				for (int w = 0; w < vexnum; w++)
				{
					if ((DistanceMatrix[v][u] != INFINITY) && (DistanceMatrix[u][w] != INFINITY) && (DistanceMatrix[v][u] + DistanceMatrix[u][w] < DistanceMatrix[v][w]))
					{//从v->u->w路径比v->w路径更短
						DistanceMatrix[v][w] = DistanceMatrix[v][u] + DistanceMatrix[u][w];
						for (int i = 0; i < vexnum; i++)
						{
							PathMatrix[v][w][i] = PathMatrix[v][u][i] || PathMatrix[u][w][i];
						}
					}
				}
			}
		}
	}

 

 

完整代码和测试用例：

// Dijkstra.cpp : 定义控制台应用程序的入口点。
// Flody算法

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<limits>
using namespace std;

#define INFINITY INT_MAX

typedef struct vexNode{
	int No;
}vexNode;

class DN{
private:
	//采用数组表示法，构造有向网
	int vexnum, arcnum;
	vector<vexNode*> vexNodePtrVec;
	vector<vector<int>> MG;
	/*路径矩阵P：PathMatrix
	P[v][w]为true则代表，则w是从源点v0到v的当前求得的最短路径上的顶点*/
	vector<vector<bool>> P;
	//final[v]为true代表，当且仅当v属于S，即已经求得从v0到v的最短路径终点
	vector<bool> Final;		
	/*最短路径记录列表D，
	记录源点v0到其他各个顶点的最短路径，D[v0]=0;
	若v0可达顶点i，则D[i]为v0->Vi的最短路径值；
	若v0不可达vi，则D[i]=INFINITE
	*/
	vector<int> D;

	/*
	法二：Flody算法：
	*/
	vector<vector<vector<bool> > > PathMatrix;
	vector<vector<int>> DistanceMatrix;

public:
	DN(){
		CreateDN();
	}
	~DN(){}
	void CreateDN()
	{
		cin >> vexnum >> arcnum;
		for (int i = 0; i < vexnum; i++)
		{
			vexNode* vexNodePtr = new vexNode;
			vexNodePtr->No = i;
			vexNodePtrVec.push_back(vexNodePtr);
			vector<int> rowVec1;
			vector<bool> rowVec2;
			for (int j = 0; j < vexnum; j++)
			{
				rowVec1.push_back(INFINITY);
				rowVec2.push_back(false);
			}
			MG.push_back(rowVec1);
			P.push_back(rowVec2);
			Final.push_back(false);
			D.push_back(INFINITY);

			vector<vector<bool>> PathMatrixDepth;
			vector<int> DistanceMatrixRow;
			for (int j = 0; j < vexnum; j++)
			{
				vector<bool> PathMatrixRow;
				for (int k = 0; k < vexnum; k++)
				{
					PathMatrixRow.push_back(false);
				}
				PathMatrixDepth.push_back(PathMatrixRow);
				DistanceMatrixRow.push_back(INFINITY);
			}

			PathMatrix.push_back(PathMatrixDepth);
			DistanceMatrix.push_back(DistanceMatrixRow);
		}
		int v1, v2, weight;
		for (int i = 0; i < arcnum; i++)
		{
			cin >> v1 >> v2 >> weight;
			MG[v1][v2] = weight;
		}
	}

	void ShortPath_DIJ(int v0)
	{//
	/*

	使用Dijkstra算法，
	求有向网DN的v0顶点到其余顶点v
	的最短路径P[v]以其带权路径长度D[v]
	v0是源点，求源点到图中其他顶点的最短路径

	DN的顶点集合V分为两个集合S  和  V-S
	从源点v0可到达的顶点集合S
	初始S={v0}
	S为已经找到的从源点v0出发的最短路径的终点集合


	P[v][w]为true表明：w是从v0到v当前求得最短路径上的顶点
	v0->v直达的就是起点v0和终点v

	Final[v]为true，当且仅当v属于S集合，表面当前已经求得的从v0到v的最短路径，
	中间过程不一定是最短，但至少表面v0到v可达

	*/

		for (int v = 0; v < vexnum; v++)
		{
			D[v] = MG[v0][v];//D[]的初始化，就是邻接表MG[v0][]上的的权值
			if (D[v] < INFINITY)
			{//D[v] < INFINITY说明v0可直达v，
				P[v][v0] = true;//路径起点的初始化：v0是从v0到v当前求得的最短路径上的顶点(起点初始化)
				P[v][v] = true;//终点初始化，v是从v0到v当前求得的最短路径上的顶点(终点初始化)
			}
		}
		D[v0] = 0;			//v0到v0的距离为0
		Final[v0] = true;	//集合S初始化，v0属于集合S
		//开始主循环，每次求得v0到某个顶点v的最短路径，并将v加入集合S
		for (int i = 0; i < vexnum; i++)
		{
			if (i == v0)
			{//除去v0的，其余的vexnum-1个顶点都遍历一遍
				continue;
			}
			else
			{
				int v = i;
				int min = INFINITY;//当前v0->v的最近距离
				for (int w = 0; w < vexnum; w++)
				{
					if (!Final[w])//w在集合V-S中
					{
						if (D[w] < min)
						{//在D向量中的属于V-S的集合中选择最小的分量
							v = w;
							min = D[w];
						}
					}
				}
				//这里的v是属于V-S集合的
				Final[v] = true;//将v加入到S集合
				//更新当前最短路径和距离
				for (int w = 0; w < vexnum; w++)
				{
					if (MG[v][w] == INFINITY)
					{//从v到w并没有路径
						continue;
					}
					else if (!Final[w] && (min + MG[v][w] < D[w]))
					{//w在集合V-S中，如果min + MG[v][w] < D[w]，将更新D[w]
						D[w] = min + MG[v][w];
						P[w] = P[v];
						P[w][w] = true;//更新终点：w是从v0到w当前求得最短路径上的终点
					}
				}
			}
		}
	}

	void PrintResultDijkstra()
	{
		std::cout << "P[][]=" << endl;
		for (int i = 0; i < vexnum; i++)
		{
			for (int j = 0; j < vexnum; j++)
			{
				if (P[i][j] == true)
				{
					std::cout << "T" << " ";
				}
				else
				{
					std::cout << "F" << " ";
				}
			}
			std::cout << endl;
		}
		std::cout << "Final[]=" << endl;
		for (int i = 0; i < vexnum; i++)
		{
			if (Final[i] == true)
			{
				std::cout << "T" << " ";
			}
			else
			{
				std::cout << "F" << " ";
			}
		}
		std::cout << endl;
		std::cout << "D[]=" << endl;
		for (int i = 0; i < vexnum; i++)
		{
			std::cout << D[i] << " ";
		}
		std::cout << endl;
	}

	/*
	法二：Flody算法：
	*/
	void ShortestPath_FLOYD()
	{
		/*
		Floyd算法求有向网G中各对顶点v和w之间的最短路径P[v][w]
		及其带权长度D[v][w]。
		若P[v][w][u]=true则表明：u是从v到w之间当前求得的最短路径上的顶点
		*/
		for (int v = 0; v < vexnum; v++)
		{
			for (int w = 0; w < vexnum; w++)
			{
				DistanceMatrix[v][w] = MG[v][w];
				if (DistanceMatrix[v][w] < INFINITY)
				{//从v到w有直达路径
					PathMatrix[v][w][v] = true;//从v->w的起点v路径标记初始化
					PathMatrix[v][w][w] = true;//从v->w的终点w路径标记初始化
				}
			}
			DistanceMatrix[v][v] = 0;
		}

		for (int u = 0; u < vexnum; u++)
		{
			for (int v = 0; v < vexnum; v++)
			{
				for (int w = 0; w < vexnum; w++)
				{
					if ((DistanceMatrix[v][u] != INFINITY) && (DistanceMatrix[u][w] != INFINITY) && (DistanceMatrix[v][u] + DistanceMatrix[u][w] < DistanceMatrix[v][w]))
					{//从v->u->w路径比v->w路径更短
						DistanceMatrix[v][w] = DistanceMatrix[v][u] + DistanceMatrix[u][w];
						for (int i = 0; i < vexnum; i++)
						{
							PathMatrix[v][w][i] = PathMatrix[v][u][i] || PathMatrix[u][w][i];
						}
					}
				}
			}
		}
	}

	void PrintDistanceMatrixFLOYD()
	{
		cout << "FLOYD算法求有向网DN的各对顶点之间的最短路径：" << endl;
		for (int i = 0; i < vexnum; i++)
		{
			for (int j = 0; j < vexnum; j++)
			{
				if (DistanceMatrix[i][j] == INFINITY)
				{
					std::cout << "NW" << " ";//No Way!
				}
				else
				{
					cout << DistanceMatrix[i][j] << " ";
				}
			}
			cout << endl;
		}
	}

};

int _tmain(int argc, _TCHAR* argv[])
{
	//溢出情况：
	//INFINITE=2147483647
	//INFINITE + 1 = -2147483648
	//cout << "INFINITE=" << INFINITY << endl;
	//cout << "INFINITE+1=" << INFINITY + 1 << endl;


	DN dn;
	//dn.ShortPath_DIJ(0);
	//dn.PrintResult();

	dn.ShortestPath_FLOYD();
	dn.PrintDistanceMatrixFLOYD();


	system("pause");
	return 0;
}

/*
6 8
0 5 100
0 4 30
0 2 10
1 2 5
2 3 50
3 5 10
4 3 20
4 5 60


输入输出：
6 8
0 5 100
0 4 30
0 2 10
1 2 5
2 3 50
3 5 10
4 3 20
4 5 60
P[][]=
F F F F F F
F F F F F F
T F T F F F
T F F T T F
T F F F T F
T F F T T T
Final[]=
T F T T T T
D[]=
0 2147483647 10 50 30 60
请按任意键继续. . .



6 8
0 5 100
0 4 30
0 2 10
1 2 5
2 3 50
3 5 10
4 3 20
4 5 60
FLOYD算法求有向网DN的各对顶点之间的最短路径：
0 NW 10 50 30 60
NW 0 5 55 NW 65
NW NW 0 50 NW 60
NW NW NW 0 NW 10
NW NW NW 20 0 30
NW NW NW NW NW 0
请按任意键继续. . .

*/

代码分享链接:链接：https://pan.baidu.com/s/17Ta8hDSY8C6XgBeHFQhIDg 密码：cyo5

 

数据结构有向网_最短路径_Dijkstra算法_Flody算法

珞喻小森林
关注
专栏目录
(建议收藏)一文多图，彻底搞懂Floyd算法(多源最短路径)
bigsai
08-27 3万+
前言 在图论中，在寻路最短路径中除了Dijkstra算法以外，还有Floyd算法也是非常经典，然而两种算法还是有区别的，Floyd主要计算多源最短路径。 在单源正权值最短路径，我们会用Dijkstra算法来求最短路径，并且算法的思想很简单—贪心算法:每次确定最短路径的一个点然后维护(更新)这个点周围点的距离加入预选队列，等待下一次的抛出确定。虽然思想很简单，实现起来是非常复杂的，我们需要邻接矩阵(表)储存长度，需要优先队列(或者每次都比较)维护一个预选点的集合。还要用一个boolean数组标记是否已经确定、
最短路Floyd算法和Dijkstra算法
zkpj12的博客
03-15 459
最短路Floyd算法和Dijkstra算法实验报告1.问题问题实例问题实例2.解析Floyd算法具体步骤Dijkstra算法具体步骤3.设计Floyd算法Dijkstra算法：4.分析Floyd算法Dijkstra算法5.源码 实验报告 课程名称 《算法分析与设计》 实验日期 2021年 3月15日 实验名称 最短路Floyd算法和Dijkstra算法 实验地点 勤园13-208 1.问题 [描述算法问题，首选形式化方式（数学语言），其次才是非形式化方式（日常语言）] 用F
C语言数据结构学习笔记(19)-有向网图的最短路径-Dijkstra算法及路径打印
laven_li的博客
11-20 1439
有向网图的最短路径-Dijkstra算法及路径打印
Floyd有向网最短路径解析
John的博客
04-04 480
Floyd相比起Dijkstra，找任意两点最短距离更加方便。然而时间复杂度也会更高，为O(n3)O(n^3)O(n3)。 下面用几张图描述算法实现具体过程 首先是一张有向网 初始化邻接矩阵A−1A_{-1}A−1​，不直接相连的两点之间权值无穷大，顶点到自己权重0。 初始化Path矩阵Path−1Path_{-1}Path−1​，每个值为-1。 -1代表两个点之间没有任何中间点。记住它是初始状...
迪杰斯特拉（Dijkstra）算法--有向网络最短路径
sinat_43009982的博客
11-10 8732
单源最短路径问题是：对于给定的有向网络G=（V，E）及单个源点v，求v到G的其余各顶点的最短路径。 算法的基本思想 a.初始时，S只包含源点，即S＝{v}，v的距离为0。U包含除v外的其他顶点，即:U={其余顶点}，若v与U中顶点u有边，则&amp;amp;amp;lt;u,v&amp;amp;amp;gt;正常有权值，若u不是v的出边邻接点，则&amp;amp;amp;lt;u,v&amp;amp;amp;gt;权值为∞。 b.从U中选取一个距离v最小的顶点k，把k，
用Dijkstra算法求有向图最短路径
qq_51224492的博客
12-13 1977
要求 1、根据输入构造一个有向网络； 2、输出该有向网络对应的矩阵； 3、求出该有向网络的最短路径。 代码 #include<stdio.h> #define INFINITY 100000 //最大值 ∞ #define MVNum 100 //最大顶点数 int D[MVNum]; //用于记录最短路的长度 bool S[MVNum];
求解有向网的最短路问题——迪杰斯特拉算法(Dijkstra)的Java语言实现。
m0_46519466的博客
02-20 288
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。
flody算法求解最短路径
最新发布
07-28
最短路径问题可以通过Dijkstra算法或者Bellman-Ford算法来解决，而Floyd算法是用来求解所有顶点对之间的最短路径的一种算法。下面是Floyd算法的步骤： 1. 创建一个二维数组dist，用于保存从任意顶点i到顶点j的最短...
Dijkstra、Floyd算法Matlab_Lingo实现.doc
10-08
Dijkstra算法是一种用于寻找图中两点间最短路径的经典算法，适用于带权重的有向或无向图，只要图中不包含负权边。下面将详细介绍Dijkstra算法在Matlab中的实现过程。 ##### 1.1 函数定义 函数`[min,path]=dijkstra...
数据结构——最短路径算法之floyd算法
qq_50675813的博客
10-30 366
数据结构——最短路径算法之floyd算法
邻接矩阵实现有向网的存储，并实现单源最短路径算法
04-03
采用邻接矩阵实现有向网的存储，建立有向网，并实现单源最短路径算法。
有向网的创建
01-29
关于有向网创建的一些基本代码，适用于初学者，建议下载，谢谢评价。
C语言数据结构学习笔记(20)-有向网图的最短路径-Floyd算法及路径打印
laven_li的博客
11-21 1040
有向网图的最短路径-Floyd算法及路径打印
c语言邻接矩阵存储有向网，使用迪杰斯特拉算法求最短路径并输出
linweiyue的博客
08-24 3056
#邻接矩阵存储有向网 在这里插入代码片
[最短路径算法-Dijkstra算法]邻接矩阵版
圣托里尼的日落啊~的博客
06-07 996
Dijkstra算法 Dijkstra算法用来解决单源最短路问题。即给定图G和起点s，通过算法得到S到达其他每个顶点的最短距离。 Dijkstra算法的基本思想是对图Ｇ(V,E)设置集合S，存放已被访问的顶点，然后每次从集合V-S中选择与起点s距离最小的一个顶点(u)，访问并加入集合S。之后，令u为中介点，优化起点s与所有从u能到达的顶点v之间的最短距离。这样的操作执行n次(n为顶点个数)，...
算法-dijkstra求最短路径（邻接表实现）
puppet_pyt的博客
03-22 4498
差不多算是第一个了解的算法，主要是做pat甲级时要用，依照的是《数据结构与算法分析》这本书； /*dijkstra算法求最短路径 邻接表表示图**/ #include //#include #define NotAVertex (-1) #define INF (1<<30) #define MAX 500 using namespace std; static int numv
稀疏有向图求最短路径
anhuibozhoushatu的专栏
11-03 347
import java.util.*; public class Youxiangtu {     public static void main(String args[]) {         Scanner in=new Scanner(System.in);         while(in.hasNext()) {             int V=in.nextInt();     ...
最短路径的Dijkstra算法（邻接表）
jacke121的专栏
02-17 5542
原文：http://blog.csdn.net/axiqia/article/details/50984464描述    以邻接表作为存储结构实现，求解从给定源点到给定结束点的最短路径。 输入从1开始表示第一个节点。第一行输入：顶点数n(2&lt;=n&lt;=100),边数m(2&lt;=m&lt;=100)第二行输入有向边：起始点s1，结束点 s2，边权值 w第三行输入：源点start，终点e...
有向图单源最短路径Dijkstra算法（高配版）
ChinMint的博客
12-22 1829
这是Dijkstra算法的高配版 (╯▔皿▔)╯其实就是可以打印出来所走的路径啦~ 找图上的某个点到其余点的最短路径 Dijkstra算法的思想： 1.将所有的点分为两种，走过的点和没走过的点     首先，原点标记为走过的第一个点，没走过的点的距离值为正无穷                看原点可以走到哪些点，将这些点的前驱改为原点 2.找到下一个可以作为原点的点：    在没走
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值