C++ 不知图系列之基于链接表的无向图最短路径搜索

最新推荐文章于 2024-04-15 14:37:00 发布
最新推荐文章于 2024-04-15 14:37:00 发布
阅读量900 收藏 2
点赞数
分类专栏： C++编程之美 文章标签： c++ 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y6123236/article/details/127884459
版权

1. 前言

图的常用存储方式有 2 种：

  • 邻接炬阵。

  • 链接表。

邻接炬阵的优点和缺点都很明显。优点是简单、易理解，但是对于大部分图结构而言，都是稀疏的，使用矩阵存储，空间浪费就较大。

链接表相比较邻接矩阵存储方案，使用起来更方便，对于空间的使用是刚好够用原则，不会产生太多空间浪费。理解起来可能会有点难度。

本文将以链接表方式存储图结构，在此基础上实现无向无权图最短路径搜索。

2. 链接表

2.1 存储思路

使用链接表实现图的存储时，有主表和子表概念。

  • 主表： 用来存储图对象中的所有顶点数据。
  • 子表： 每一个顶点自身会维护一个子表，用来存储与其相邻的所有顶点数据。

如下图结构中有 5 个顶点，使用链接表保存时，需要主表 1 张，子表 5 张。链接表的优点是能够紧凑地表示稀疏图。

图1.png

邻接表01.png

2.2 图的存储实现

2.2.1 项点类

因顶点本身是具有特定的数据含义（如，可能是城市、公交车站、网址、路由器……），需要一个顶点类承载顶点的有效数据。并在顶点类中提供维护自身信息的函数。

#include <iostream>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
template<typename T>
struct Vertex {
	// 顶点的编号
	int vid;
	// 顶点有效负荷
	T value;
	// 是否被访问过:False 没有 True:有
	bool visited ;
    
    //相邻顶点类型
	template<typename T1>
	struct NeighborVertex {
		Vertex<T1> *vertex;
		//和相邻顶点的权重
		int weigth;
		//兄弟顶点
		NeighborVertex<T1> *next;
		NeighborVertex(	Vertex<T1> *ver,int weigth) {
			this->vertex=ver;
			this->weigth=weigth;
			this->next=NULL;
		}
	};
	// 相邻顶点链表
	NeighborVertex<T> *  head;
	//搜索时的前驱结点
	Vertex* preVertex;
    //无参构造
	Vertex() {
		this->vid=0;
		this->visited=false;
		this->head=NULL;
	}
    //有参构造
	Vertex(int vid,T value) {
		this->vid=vid;
		this->visited=false;
		this->head=NULL;
		this->value=value;
	}
	/*
	*在链表中使用头部插入方案添加邻接顶点
	*nbrVer:相邻顶点
	*weight:无向无权重图，权重默认设置为 1
	*/
	void addNeighbor(Vertex<T> *nbrVer,int weigth) {
		NeighborVertex<T> * newNbrVer=new NeighborVertex<T>(nbrVer,weigth);
		//头部添加
		if(this->head==NULL) {
			this ->head=newNbrVer;
		} else {
			newNbrVer->next=this->head;
			this->head=newNbrVer;
		}
	}
	
    /*
	*   显示与当前顶点相邻的顶点
	*/
	vector<Vertex<T> *> showAllNeighbor() {
		NeighborVertex<T> *move=this->head;
		vector<Vertex<T> *> allNeighbor;
		while(move!=NULL) {
			allNeighbor.push_back(move->vertex);
			move->vertex->desc();
			cout<<"_权重"<<move->weigth<<"\t";
			move=move->next;
		}
		return allNeighbor;
	}
	/*
	*判断与某顶点是否相邻，并返回权重  0 表示与此顶点不相邻
	*/
	int  isNeighbor(NeighborVertex<T> *ver) {
		NeighborVertex<T> *move=this->head;
		while(move!=NULL && move->vertex->value!=ver->value) {
			move=move->next;
		}
		if (move==NULL)
			return 0;
		else
			return move->weigth;
	}

	//顶点的自我显示
	void desc() {
		cout<<"顶点["<<this->vid<<"_"<<this->value<<"]";
	}
};

顶点类结构需要说明地方：

  • visited：用于搜索路径算法中，检查节点是否已经被搜索过。
  • head：存储与顶点相邻的顶点信息，也称为相邻顶点，相邻顶点需要包括 2 方面信息，一是顶点Vertex信息，二是权重。这里提供了NeighborVertex类型，在Vertex类型的基础之上封装了权重。

父子表.png

2.2.2 图类

图类用于维护l图中的所有顶点以及顶点之间的关系，以及针对于图的相关算法。

template<typename T>
class Graph {
	private:
		// 一维数组，存储节点
		Vertex<T>** vertexs;
		// 顶点编号,从 0 开始
		int vnums;
		//一维数组大小
		int size;
	public:
		Graph(int size) {
			//初始一给数组大小
			this->vertexs=new Vertex<T>*[size];
			this->vnums=0;
			this->size=size;
		}
		//添加新顶点
		Vertex<T> * addVertex(T value);
		//为顶点添加相邻顶点
		void addNeighbor(T parentValue,T nbrValue,int weight);
		//按值查找顶点
		Vertex<T> * findVertexByValue(T value);
		//按编号查找顶点
		Vertex<T> * findVertexById(int id);
		//显示所有顶点
		void showAllVers();
};
查找函数：

查找算法有 2 种方案：

  • 按值查找。
/*
*按值查找顶点是否存在
*/
template<typename T>
Vertex<T> * Graph<T>::findVertexByValue(T value) {
	for(int i=0; i<Graph<T>::vnums; i++) {
		if(Graph<T>::vertexs[i]==NULL)
			continue;
		if(Graph<T>::vertexs[i]->value==value) {
			return Graph<T>::vertexs[i];
		}
	}
	return NULL;
}
  • 按编号查找。
/*
*按编号查找顶点是否存在
*/
template<typename T>
Vertex<T> * Graph<T>::findVertexById(int id) {
	for(int i=0; i<Graph<T>::vnums; i++) {
		if(Graph::vertexs[i]->vid==id) {
			return Graph<T>::vertexs[i];
		}
	}
	return NULL;
}

添加新顶点函数： 先查找是否存在顶点，没有就添加。

顶点的编号由图对象内部指定，便于统一管理。

/*
*添加新的顶点
*/
template<typename T>
Vertex<T> * Graph<T>::addVertex(T value) {
	//检查此顶点是否存在
	Vertex<T> * ver= Graph<T>::findVertexByValue(value);
	if(ver==NULL) {
		//创建新的顶点
		ver=new  Vertex<T>(Graph<T>::vnums,value);
		Graph::vertexs[Graph<T>::vnums]=ver;
		Graph<T>::vnums++;
	}
	return ver;
}

添加顶点之间的关系：

//为顶点添加相邻顶点
template<typename T>
void Graph<T>::addNeighbor(T parentValue,T nbrValue,int weight) {
	Vertex<T> * parentVer= Graph<T>::findVertexByValue(parentValue);
	if(parentVer==NULL)
		parentVer=Graph<T>::addVertex(parentValue);
	Vertex<T> * nbrVer= Graph<T>::findVertexByValue(nbrValue);
	if(nbrVer==NULL)
		nbrVer=Graph<T>::addVertex(nbrValue);
	//调用顶点的函数
	parentVer->addNeighbor(nbrVer,weight);
}

显示所有顶点：

template<typename T>
void Graph<T>::showAllVers() {
	for(int i=0; i<Graph<T>::vnums; i++) {
		Graph::vertexs[i]->desc();
		cout<<endl<<"\t相邻顶点：";
		//输出相邻顶点
		Graph::vertexs[i]->showAllNeighbor();
		cout<<endl;
	}
}

测试图中的函数：

存储如下图结构中顶点以及顶点之间的信息：

图1.png

int main(int argc, char** argv) {
	//实例化图
	Graph<char> *graph=new Graph<char>(10);
	//添加几个顶点 A，B C D E
	char vers[5]= {'A','B','C','D','E'};
	for(int i=0; i<5; i++) {
		graph->addVertex(vers[i]);
	}
	//添加顶点之间的关系（A -(3)-》B ）
	graph->addNeighbor('A','B',3);
	//添加顶点之间的关系（A -(5)-》D ）
	graph->addNeighbor('A','D',5);
	//添加顶点之间的关系（B -(4)-》c ）
	graph->addNeighbor('B','C',4);
	//添加顶点之间的关系（C -(6)-》D）
	graph->addNeighbor('C','D',6);
	//添加顶点之间的关系（C -(1)-》E）
	graph->addNeighbor('C','E',1);
	//添加顶点之间的关系（D -(2)-》E）
	graph->addNeighbor('D','E',2);
	//添加顶点之间的关系（E -(7)-》B）
	graph->addNeighbor('E','B',7);
	//输出所的顶点
	graph->showAllVers();
	return 0;
}

输出结果：

res.png

3. 最短路径算法

从图结构可知，从一个顶点到达另一个顶点，不止一条可行路径，在众多路径我们总是试图选择一条最短路径。当然，需求不同，衡量一个路径是不是最短路径的标准也会不同。

如打开导航系统后，最短路径可能是费用最少的那条、可能是速度最快的那条、也可能是量程数最少的或者是红绿灯最少的……

在无权无向图中，以经过的边数最少的路径为最短路径。在无权无向图中找到最短路径相对简单。

在有向加权图中，会以附加在每条边上的权重的数据含义来衡量。权重可以是时间、速度、量程数……

3.1 算法思路

查找无向图中任意两个顶点间的最短路径长度，可以直接使用广度搜索算法。如下图求解 A0 ~ F5 的最短路径。

Tips： 无向图中任意 2 个顶点间的最短路径长度由边数决定。

无向无权重图.png

广度优先搜索算法流程：

广度优先搜索算法的基本原则：以某一顶点为参考点，先搜索离此顶点最近的顶点，再搜索离最近顶点的最近顶点……以此类推，一层一层向目标顶点推进。

如从顶点 A0 找到顶点 F5。先从离 A0 最近的顶点 B1、D3 找起，如果没找到，再找离 B1、D3 最近的顶点 C2、E4，如果还是没有找到，再找离 C2、E4 最近的顶点 F5。

Tips： 因为每一次搜索都是采用最近原则，最后搜索到的目标也一定是最近的路径。

也因为采用最近原则，在搜索过程中所经历到的每一个顶点的路径都是最短路径。最近+最近，结果必然还是最近。

无向无权重图00.png

显然，广度优先搜索的最近搜索原则是符合先进先出思想的，具体算法实施时可以借助队列实现整个过程。

算法流程：

  • 先确定起始点 A0。

  • 找到 A0 的 2 个后序顶点 B1 、D3 （或者说 B1、D3的前序顶点是 A0），压入队列中。除去起点 A0，B1、D3 顶点属于第一近压入队列的节点。

    B1 和 D3 压入队列的顺序并不影响 A0 ~B1 或 A0 ~ D3 的路径距离（都是 1）。

    A0~B1 的最短路径长度为 1。

    A0~D3 的最短路径长度为 1。

  • 从队列中搜索 B1 时，找到 B1 的后序顶点 C2 并压入队列。B1 是 C2 的前序顶点。

    B1 ~ C2 的最短路径长度为 1，而又因为 A0~B1 的最短路径长度为 1 ，所以 A0 ~ C2 的最短路径为 2

  • B1 搜索完毕后，在队列中搜索 B3 时，找到 B3 的后序顶点 E4 ，压入队列。因 B1 和 D3 属于第一近顶点，所以这 2 个顶点的后序顶点 C2、E4 属于第二近压入队列，或说 A0-B1-C2、A0-D3-E4 的路径距离是相同的（都为 2）。

  • 当搜索到 C2 时，此时队列没有压入操作。

  • 当 搜索到 E4 时，E4 有 2 个相邻顶点 C2、F5，因 C2 已经压入过，所以仅压入 F5。因 F5 是由第二近顶点压入，所以 F5 是属于第三近压入顶点。

    A0-D3-E4-F5 的路径为 3。

无向无权重图01.png

3.2 编码实现

在图类添加广度搜索函数：

在图类添加如下函数：使用广度优先搜索算法查找顶点与顶点之间的路径。

广度优先搜索算法有一个核心点，当搜索到某一个顶点后，需要找到与此顶点相邻的其它顶点，并压入队列中。pushQueue 方法就是做这件事情的。如果某一个顶点曾经进过队列，就不要再重复压入队列了。

 template<typename T>
class Graph {
	private:
         //省略……
         //保存所有使用广度算法搜索到的路径
		vector<vector<Vertex<T> *> >  allPaths;
	public:
         //省略……
		//把某一顶点的相邻顶点压入队列
		void pushQueue(queue<Vertex<T> *> & myQueue,Vertex<T> * vertex);
		//广度搜索路径
		void bfsNearestPath(T from,T to);
		//输出广度搜索到的所有路径
		void showAllPaths();
	};

pushQueue的函数实现：

//把某一顶点的相邻顶点压入队列
template<typename T>
void  Graph<T>::pushQueue(queue<Vertex<T> *> & myQueue,Vertex<T> *  vertex) {
	//查找  vertex 的相邻顶点
	cout<<vertex->value<<"相邻顶点:"<<endl;
	vector<Vertex<T> *> allVers=vertex->showAllNeighbor();	
	for(int i=0; i<allVers.size(); i++) {
		if(allVers[i]->visited==false) {
			//设置前驱顶点
			allVers[i]->preVertex=vertex;
			//压入队列中
			myQueue.push(allVers[i]);
			//设置为已经压入
			allVers[i]->visited=true;
		}
	}
	cout<<endl;
}

bfsNearestPath广度搜索算法实现：

//广度搜索路径
template<typename T>
void Graph<T>::bfsNearestPath(T from,T to) {
	//队列：广度搜索要使用队列
	queue<Vertex<T> *>  myQueue;
	//临时路径
	vector<Vertex<T> *> tmpPath;
	//检查顶点是否存在
	Vertex<T> * fromVer= Graph<T>::findVertexByValue(from);
	Vertex<T> * toVer= Graph<T>::findVertexByValue(to);
	if(fromVer==NULL || toVer==NULL)
		return;
	tmpPath.push_back(fromVer);
	//把 fromVer 顶点的相邻顶点压入队列中,fromVer 本身可以不用压入
	Graph<T>::pushQueue(myQueue,fromVer);

	while(!myQueue.empty()) {
		//出队列
		Vertex<T> * ver=  myQueue.front();
		myQueue.pop();
		if(ver->preVertex==fromVer) {
			//如果前驱是 fromVer
			tmpPath.push_back(ver);
			//添加新路径
			Graph<T>::allPaths.push_back(tmpPath);
			//把临时路径的最后一个顶点删除
			tmpPath.pop_back();
		} else {
			//扫描所有路径
			for(int i=0; i<Graph<T>::allPaths.size(); i++) {
				tmpPath = Graph<T>::allPaths[i];
				//得到路径中的最后一个顶点
				Vertex<T> * tmpVer =tmpPath.back();
				if (ver->preVertex==tmpVer) {
					tmpPath.push_back(ver);
					//allPaths[i]=tmpPath;
					Graph<T>::allPaths.push_back(tmpPath);
				}
			}
		}
		if(ver->value==toVer->value) {
			break;
		} else {
			Graph<T>::pushQueue(myQueue,ver);
		}
	}
}

显示顶点之间的路径信息：

/*
*显示搜索到的路径
*/
template<typename T>
void Graph<T>::showAllPaths() {
	for(int i=0; i<Graph<T>::allPaths.size(); i++) {
		vector<Vertex<T> *> vec=Graph<T>::allPaths[i];
		int pathWeight=0;
		for(int j=0; j<vec.size(); j++) {
			pathWeight++;
			vec[j]->desc();
			cout<<"-";
		}
		cout<<"路径长度："<<pathWeight-1<<endl;
	}
}

测试代码： 因为测试的是无向无权重图，顶点之间的权重默认为 1。

nt main(int argc, char** argv) {
	//实例化图
	Graph<char> *graph=new Graph<char>(10);
	//添加几个顶点 A，B C D E
	char vers[6]= {'A','B','C','D','E','F'};
	for(int i=0; i<6; i++) {
		graph->addVertex(vers[i]);
	}

	//添加顶点之间的关系（A -(3)-》B ）
	graph->addNeighbor('A','B',1);
	//添加顶点之间的关系（A -(5)-》D ）
	graph->addNeighbor('A','D',1);
	//添加顶点之间的关系（B -(4)-》c ）
	graph->addNeighbor('B','C',1);
	//添加顶点之间的关系（C -(6)-》D）
	graph->addNeighbor('D','E',1);
	//添加顶点之间的关系（C -(1)-》E）
	graph->addNeighbor('C','E',1);
	//添加顶点之间的关系（D -(2)-》E）
	graph->addNeighbor('E','F',1);
	//输出所的顶点
	graph->showAllVers();
	//广度搜索A 到 F 的路径，中间会经过其它顶点
	graph->bfsNearestPath('A','F');
	cout<<"\n路径信息:"<<endl;
	graph->showAllPaths();
	return 0;
}

输出结果：

paths.png

无向无权重图中，查找起始点到目标点的最短路径，使用广度优先搜索算法便可实现。

但如果是有向加权图，可能不会称心如愿。因有向加权图中的边是有权重的。故对于有向加权图则需要另择方案。

4. 总结

本文讲解了如何使用链表存储图，以及使用广度搜索算法实现无向无权重图中顶点之间的路径搜索。

一枚大果壳
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
精解C语言最短路径算法：有向与无向图最短路径Dijkstra算法和节点输出
源代码杀手的博客
09-18 1659
#include <stdio.h> #include <stdlib.h> #define max1 10000000; //原词条这里的值太大，导致溢出，后面比较大小时会出错 int a[1000][1000]; int d[1000]; //d表示源节点到该节点的最小距离 int p[1000]; //p标记访问过的节点 int i, j, k; int m; //m代表边数 int n; //n代表点数 int main() { scanf("%d%d", &
C++数据结构之图的最短路径——Dijkstra&Floyd(包含算法实现以及gif图示)
m0_56398315的博客
09-04 4509
本文包含了对最短路径以及相关概念的解释，以及Dijkstra和Floyd算法求最短路径的C++算法实现，并包含了gif演示和相关图示
无向图最短路径
最新发布
cml814的博客
04-15 237
给出一个无向图，求起点1到其它所有点的最短距离。 输入格式 第一行输入n, m。n是定点数量，m是边的数量 第2~m+1行，每行三个数u, v, w，分别表示单向边的起点，终点和边的长度。1
图结构练习——最短路径
数据结构实验之栈与队列十一：refresh的停车场
07-15 159
图结构练习——最短路径 Description 给定一个带权无向图，求节点1到节点n的最短路径。 Input 输入包含多组数据，格式如下。 第一行包括两个整数n m，代表节点个数和边的个数。(n<=100) 剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。 Output 每组输出占一行，仅输出从1到n的最短路径权值。（保证最短路径存在） Sample Input 3 2 1 2 1 1 3 1 1 0 Output 1 0 #include <bits/stdc++.
【C++】Dijkstra算法解决最短路径问题
Mitchell_Donovan的博客
05-18 1659
最短路径问题 问题描述：平面上有n个点（n<=100），每个点的坐标均在-10000～10000之间。其中的一些点之间有连线。若有连线，则表示可从一个点到达另一个点，即两点间有通路，通路的距离为两点间的直线距离。现在的任务是找出从一点到另一点之间的最短距离。 输入： 第1行为整数n，表示图中顶点的个数。 第2行到第n+1行（共n行），每行两个整数x和y，描述了一个点的坐标（以一个空格分隔）。 第n+2行为一个整数m，表示图中连线的个数。 此后的m行，每行描述一条连线，由两个整数i和j.
C++图论 最短路问题总结
m0_62946761的博客
12-29 8700
C++ 图论关于最短路问题的总结，包括Dijkstra，Bellman_ford，spfa算法等。
数据结构图实验报告.doc
12-23
"一、实验目的和要求 " "（1）掌握图的相关概念，包括图，有向图，无向图，完全图，子图，连通图，度，入 " "度，出度，简单回路和环等定义。 " "（2）重点掌握图的各种存储结构，包括邻接矩阵和邻接表等。 " "（3）...
数据结构C++描述
03-15
12.5 无向图和有向图的描述 371 12.5.1 邻接矩阵 371 12.5.2 邻接压缩表 373 12.5.3 邻接链表 374 12.6 网络描述 375 12.7 类定义 376 12.7.1 不同的类 376 12.7.2 邻接矩阵类 377 12.7.3 扩充Chain类 380 12.7.4 类...
C++语言描述(PDF合集)
07-13
12.5 无向图和有向图的描述 371 12.5.1 邻接矩阵 371 12.5.2 邻接压缩表 373 12.5.3 邻接链表 374 12.6 网络描述 375 12.7 类定义 376 12.7.1 不同的类 376 12.7.2 邻接矩阵类 377 12.7.3 扩充Chain类 380 12.7.4 类...
数据结构算法与应用-C++语言描述
10-20
12.5 无向图和有向图的描述 371 12.5.1 邻接矩阵 371 12.5.2 邻接压缩表 373 12.5.3 邻接链表 374 12.6 网络描述 375 12.7 类定义 376 12.7.1 不同的类 376 12.7.2 邻接矩阵类 377 12.7.3 扩充Chain类 380 12.7.4 类...
数据结构与算法：C++描述
11-10
12.5 无向图和有向图的描述 371 12.5.1 邻接矩阵 371 12.5.2 邻接压缩表 373 12.5.3 邻接链表 374 12.6 网络描述 375 12.7 类定义 376 12.7.1 不同的类 376 12.7.2 邻接矩阵类 377 12.7.3 扩充Chain类 380 12.7.4 类...
Dijkstra算法求无向图单源最短路径(C语言实现）
06-06
程序采用读.dat文件的方式，获得顶点和弧，设置菜单栏，可供循环使用。
五步法寻找无向图节点之间所有路径
SpaceSunflower 's ML/DL home
10-11 570
【知识图谱寻找路径】五步法寻找无向图节点之间的所有路径
计算无向无权图中两点间所有的最短路径
xiayingping的专栏
02-23 8844
一、例子 如上图，节点0到节点5的最短路径长度为3，有两条最短路径： 路径1：0 — 1 — 4— 5 路径2：0 — 1 — 2— 5 计算过程：首先计算起点0与终点5间的最短距离，从起点0，搜索0的相邻节点，只有节点1，所以节点1一定在最短路径中，然后计算节点1的相邻节点，有节点2和节点4，假设搜索从序号小的开始，那么节点4   二、相关名称 tempLadder：
最短路径算法--无权最短路径
杨春建的博客
09-19 6726
输入是一个赋权图：与每条边（vi，vj）相联系的是穿越该弧的代价（或称为值）ci,j。一条路径v1v2v3…vN的值是，叫做赋权路径长（weighted path length），而无权路径长（unweighted path length）只是路径上的边数，即N-1。 单源路径问题   给定一个赋权图G=（V，E）和一个特定顶点s作为输入，找出从s到G中每一个其它顶点的最短赋权路径。
数据结构与算法——图论基础与图存储结构
程序员吴师兄的博客
03-25 2066
1 前言由于后续更新「面试专场」的好几篇文章都涉及到图这种数据结构，因此打算先普及一下 图 的相关理论支持，如果后面的相关内容有些点不太容易理解，可以查阅此篇文章。本...
C++ 最短路径
struct_GS的博客
08-28 8291
目录： 最短路径简介 Floyd算法 \ Floyd-warshall算法 Dijkstra算法 Bellman-Ford算法 \ SPFA算法 Johnson算法 A*算法 最短路径简介： 最短路径问题是图论研究中的一个经典算法问题， 旨在寻找图（由结点和路径组成的）中两结点之间的最短路径。 算法具体的形式包括： (1)确定起点的最短路径问题（即已知起始结点），求最短路径的问题。 (2)确定终点的最短路径问题（与确定起点的问题相反），...
图的最短路径问题（C++）
nanfang0的博客
01-01 2242
最短路径问题主要分为两种，单源和多源。 对于无权的单源最短路径问题，因其所有边长相等，在使用广度优先搜索时距离一定是从0开始依次向外扩展一层，不会突然出现一个顶点使得之前录入的路径缩短。 那么就只需要在广度优先搜索的过程中加入可以记录距离和路径的容器即可。 class unweighted { public: vector<vector<int>>map;//邻接矩阵 vector<int>dis;//记录距离的...
无向图最短路径c++
05-28
你可以使用广度优先搜索（BFS）来求无向图的最短路径。 下面是一个基于邻接表的C++代码示例： ```cpp #include <iostream> #include <queue> #include <vector> using namespace std; const int MAXN = 100005; // 最大节点数 vector<int> g[MAXN]; // 邻接表存储图 int dist[MAXN]; // 存储每个节点到起点的最短距离 bool vis[MAXN]; // 记录每个节点是否已经访问过 void bfs(int s) { queue<int> q; q.push(s); dist[s] = 0; vis[s] = true; while (!q.empty()) { int u = q.front(); q.pop(); for (int i = 0; i < g[u].size(); i++) { int v = g[u][i]; if (!vis[v]) { dist[v] = dist[u] + 1; vis[v] = true; q.push(v); } } } } int main() { int n, m; // n是节点数，m是边数 cin >> n >> m; for (int i = 1; i <= m; i++) { int u, v; cin >> u >> v; g[u].push_back(v); g[v].push_back(u); } int s, t; // 起点和终点 cin >> s >> t; bfs(s); cout << dist[t] << endl; return 0; } ``` 该示例代码从标准输入读入无向图的节点数和边数，然后读入每条边的起点和终点。接着读入起点和终点，然后使用BFS求出起点到终点的最短距离，并输出结果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一枚大果壳

码文不易，晚上熬夜需要点咖啡钱

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值