习题2-5 最短路径和简单路径

最新推荐文章于 2024-04-27 13:02:46 发布
最新推荐文章于 2024-04-27 13:02:46 发布
阅读量866 收藏 4
点赞数 1
分类专栏： 数据结构作业 文章标签： 图论 深度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65185254/article/details/128233887
版权

第1关：习题2 DFS非递归

//算法6.2　采用邻接表表示法创建无向图

#include <iostream>
#include <stack> 
using namespace std;

#define MVNum 100                        	//最大顶点数 
#define OK 1
#define ERROR 0

bool visited[100];
typedef char VerTexType;					//顶点信息
typedef int OtherInfo;						//和边相关的信息 

//- - - - -图的邻接表存储表示- - - - - 
typedef struct ArcNode{                		//边结点 
    int adjvex;                          	//该边所指向的顶点的位置 
    struct ArcNode *nextarc;          		//指向下一条边的指针 
    OtherInfo info;                      	//和边相关的信息 
}ArcNode; 

typedef struct VNode{ 
    VerTexType data;                    	//顶点信息 
    ArcNode *firstarc;                		//指向第一条依附该顶点的边的指针 
}VNode, AdjList[MVNum];               		//AdjList表示邻接表类型 

typedef struct{ 
    AdjList vertices;                 		//邻接表 
    int vexnum, arcnum;              		//图的当前顶点数和边数 
}ALGraph;


int LocateVex(ALGraph G , VerTexType v)
{
	//确定点v在G中的位置
	for(int i = 0; i < G.vexnum; ++i)
		if(G.vertices[i].data == v)
			return i;
    return -1;
}//LocateVex

int CreateUDG(ALGraph &G)
{ 
	//采用邻接表表示法，创建无向图G
	int i , k;
	cin >> G.vexnum >> G.arcnum;				//输入总顶点数，总边数 
	for(i = 0; i < G.vexnum; ++i)
	{          	//输入各点，构造表头结点表
	
		cin >> G.vertices[i].data;           	//输入顶点值 
		G.vertices[i].firstarc=NULL;			//初始化表头结点的指针域为NULL 
    }//for

	for(k = 0; k < G.arcnum;++k)
	{        		//输入各边，构造邻接表
		VerTexType v1 , v2;
		int i , j;

		cin >> v1 >> v2;                 		//输入一条边依附的两个顶点
		i = LocateVex(G, v1);  j = LocateVex(G, v2);
		//确定v1和v2在G中位置，即顶点在G.vertices中的序号 

		ArcNode *p2=new ArcNode;                //生成另一个对称的新的边结点*p2 
		p2->adjvex=j;                   		//邻接点序号为i 
		p2->nextarc= G.vertices[i].firstarc;  
		G.vertices[i].firstarc=p2;  
		//将新结点*p2插入顶点vj的边表头部 
    }//for 
    return OK; 
}//CreateUDG
void DFS(ALGraph G, VerTexType v)
{
	/************************Begin****************/
    int k = LocateVex(G,v);

    stack <int> s;
    visited[k] = true;
    s.push(k);

    while(!s.empty())
    {
        int t = s.top();
        cout << G.vertices[t].data << ' ';
        s.pop();

        ArcNode *p = G.vertices[t].firstarc;
        while(p)
        {
            int j = p -> adjvex;
            if(!visited[j]) 
            {
                visited[j] = true;
                s.push(j);
            }

            p = p -> nextarc;
        }
    }
    /***********************End******************/
}
void show(ALGraph G)
{
	for(int i = 0 ; i < G.vexnum ; ++i)
	{
		VNode temp = G.vertices[i];
		ArcNode *p = temp.firstarc;
		if(p == NULL)
		{
			cout << G.vertices[i].data;
			cout << endl;
		}
		else
		{
			cout << temp.data;
			while(p)
			{
				cout << "->";
				cout << G.vertices[p->adjvex].data;
				p = p->nextarc;
			}
		}
		cout << endl;
	}	
}

int main()
{
	ALGraph G;
	CreateUDG(G);

    VerTexType v;
    cin >> v;
    DFS(G, v);
	

	return 0;
}//main

第2关：习题3 最短路径-邻接矩阵表示

#include <iostream>
using namespace std;

#define MaxInt 32767                   	//表示极大值，即∞
#define MVNum 100                       	//最大顶点数
#define OK 1	
#define ERROR 0
 						
typedef char VerTexType;              		//假设顶点的数据类型为字符型 
typedef int ArcType;                  		//假设边的权值类型为整型 
int D[MVNum];
bool S[MVNum];
int Path[MVNum];
//- - - - -图的邻接矩阵存储表示- - - - -
typedef struct{ 
	VerTexType vexs[MVNum];            		//顶点表 
	ArcType arcs[MVNum][MVNum];      		//邻接矩阵 
	int vexnum,arcnum;                		//图的当前点数和边数 
}AMGraph;

int LocateVex(AMGraph G , VerTexType v){
	//确定点v在G中的位置
	for(int i = 0; i < G.vexnum; ++i)
		if(G.vexs[i] == v)
			return i;
   return -1;
}//LocateVex

int CreateUDN(AMGraph &G){ 
    //采用邻接矩阵表示法，创建无向网G 
	int i , j , k, w;
    cin >> G.vexnum >> G.arcnum;							//输入总顶点数，总边数
    for(i = 0; i < G.vexnum; ++i){   	
		cin >> G.vexs[i];                        			//依次输入点的信息 
	}
    for(i = 0; i < G.vexnum; ++i)                			//初始化邻接矩阵，边的权值均置为极大值MaxInt 
		for(j = 0; j < G.vexnum; ++j)   
			G.arcs[i][j] = MaxInt;  
	for(k = 0; k < G.arcnum;++k){							//构造邻接矩阵 
		VerTexType v1 , v2;
		cin >> v1 >> v2 >> w;								//输入一条边依附的顶点及权值
		i = LocateVex(G, v1);  j = LocateVex(G, v2);		//确定v1和v2在G中的位置，即顶点数组的下标 
		G.arcs[i][j] = w;									//边<v1, v2>的权值置为w 					
	}//for	
	return OK; 
}//CreateUDN 
int ShortestPathMax(AMGraph G, VerTexType v)
{
	/*************************Begin*********************/
    int k = LocateVex(G,v);
    int n = G.vexnum,i,w,t;

	for(t = 0;t < n; ++ t )
	{ 
		S[t] = false; 
		D[t] = G.arcs[k][t]; 
		if(D[t]< MaxInt) Path[t] = k; 
		else Path [t]=-1; 
	} 

	S[k]=true;
	D[k]=0; 
	
	for(i=1;i<n; ++i)
    { 
		int min= MaxInt; 
		for(w=0;w<n; ++w) 
			if(!S[w]&&D[w]<min) 
				{t=w; min=D[w];} 

		S[t]=true; 
		for(w=0;w<n; ++w) 
			if(!S[w]&&(D[t]+G.arcs[t][w]<D[w])){ 
				D[w]=D[t]+G.arcs[t][w]; 
				Path [w]=t; 
			}
	}

	int Max=D[0]; 
	int m=0; 
	for(i=1;i<n;i++) 
		if(Max<D[i]) m = i; 
	return m - 1; 
    /*************************End************************/
} 

int main(){
	
	AMGraph G;
	CreateUDN(G);

	VerTexType v;
	cin >> v;
	int p = ShortestPathMax(G, v);
	cout << G.vexs[p];
	
	return 0;
}//main

第3关：习题4 有向图邻接表表示深搜路径

#include <iostream>
#include <stack> 
using namespace std;

#define MVNum 100                        	//最大顶点数 
#define OK 1
#define ERROR 0


typedef char VerTexType;					//顶点信息
typedef int OtherInfo;						//和边相关的信息 


//- - - - -图的邻接表存储表示- - - - - 
typedef struct ArcNode{                		//边结点 
    int adjvex;                          	//该边所指向的顶点的位置 
    struct ArcNode *nextarc;          		//指向下一条边的指针 
    OtherInfo info;                      	//和边相关的信息 
}ArcNode; 

typedef struct VNode{ 
    VerTexType data;                    	//顶点信息 
    ArcNode *firstarc;                		//指向第一条依附该顶点的边的指针 
}VNode, AdjList[MVNum];               		//AdjList表示邻接表类型 

typedef struct{ 
    AdjList vertices;                 		//邻接表 
    int vexnum, arcnum;              		//图的当前顶点数和边数 
}ALGraph;


int LocateVex(ALGraph G , VerTexType v)
{
	//确定点v在G中的位置
	for(int i = 0; i < G.vexnum; ++i)
		if(G.vertices[i].data == v)
			return i;
    return -1;
}//LocateVex

int CreateUDG(ALGraph &G)
{ 
	//采用邻接表表示法，创建无向图G
	int i , k;
	cin >> G.vexnum >> G.arcnum;				//输入总顶点数，总边数 
	for(i = 0; i < G.vexnum; ++i)
	{          	//输入各点，构造表头结点表
	
		cin >> G.vertices[i].data;           	//输入顶点值 
		G.vertices[i].firstarc=NULL;			//初始化表头结点的指针域为NULL 
    }//for

	for(k = 0; k < G.arcnum;++k)
	{        		//输入各边，构造邻接表
		VerTexType v1 , v2;
		int i , j;

		cin >> v1 >> v2;                 		//输入一条边依附的两个顶点
		i = LocateVex(G, v1);  j = LocateVex(G, v2);
		//确定v1和v2在G中位置，即顶点在G.vertices中的序号 

		ArcNode *p2=new ArcNode;                //生成另一个对称的新的边结点*p2 
		p2->adjvex=j;                   		//邻接点序号为i 
		p2->nextarc= G.vertices[i].firstarc;  
		G.vertices[i].firstarc=p2;  
		//将新结点*p2插入顶点vj的边表头部 
    }//for 
    return OK; 
}//CreateUDG
int flag = 0; //注意flag
bool visited[MVNum];
void PathDFS(ALGraph G, VerTexType v, VerTexType w)
{	
    /**********************Begin********************/
    int i = LocateVex(G,v),j = LocateVex(G,w);

    int level = 0;

    if(i==j) flag = 1;
	else 
	{ 
		visited[i]=1; 
		for(ArcNode *p = G.vertices[i].firstarc;p;p=p->nextarc,level -- ) 
		{
			level++; 
			int k = p->adjvex; 
			if(!visited[k]) PathDFS(G,G.vertices[k].data,w);
		}
	}

    if(level == 1) flag = 1;
    /**********************End**********************/
    
}
void show(ALGraph G)
{
	for(int i = 0 ; i < G.vexnum ; ++i)
	{
		VNode temp = G.vertices[i];
		ArcNode *p = temp.firstarc;
		if(p == NULL)
		{
			cout << G.vertices[i].data;
			cout << endl;
		}
		else
		{
			cout << temp.data;
			while(p)
			{
				cout << "->";
				cout << G.vertices[p->adjvex].data;
				p = p->nextarc;
			}
		}
		cout << endl;
	}	
}

int main()
{
	ALGraph G;
	CreateUDG(G);

    VerTexType m, n;
    cin >> m >> n;
    PathDFS(G, m, n);
    cout << flag;
	
	return 0;
}//main

第4关：习题5 无向图邻接表表示长度为k的路径

#include <iostream>
#include <stack> 
using namespace std;

#define MVNum 100                        	//最大顶点数 
#define OK 1
#define ERROR 0


typedef char VerTexType;					//顶点信息
typedef int OtherInfo;						//和边相关的信息 


//- - - - -图的邻接表存储表示- - - - - 
typedef struct ArcNode{                		//边结点 
    int adjvex;                          	//该边所指向的顶点的位置 
    struct ArcNode *nextarc;          		//指向下一条边的指针 
    OtherInfo info;                      	//和边相关的信息 
}ArcNode; 

typedef struct VNode{ 
    VerTexType data;                    	//顶点信息 
    ArcNode *firstarc;                		//指向第一条依附该顶点的边的指针 
}VNode, AdjList[MVNum];               		//AdjList表示邻接表类型 

typedef struct{ 
    AdjList vertices;                 		//邻接表 
    int vexnum, arcnum;              		//图的当前顶点数和边数 
}ALGraph;


int LocateVex(ALGraph G , VerTexType v)
{
	//确定点v在G中的位置
	for(int i = 0; i < G.vexnum; ++i)
		if(G.vertices[i].data == v)
			return i;
    return -1;
}//LocateVex

int CreateUDG(ALGraph &G)
{ 
	//采用邻接表表示法，创建无向图G
	int i , k;
	cin >> G.vexnum >> G.arcnum;				//输入总顶点数，总边数 
	for(i = 0; i < G.vexnum; ++i)
	{          	//输入各点，构造表头结点表
	
		cin >> G.vertices[i].data;           	//输入顶点值 
		G.vertices[i].firstarc=NULL;			//初始化表头结点的指针域为NULL 
    }//for

	for(k = 0; k < G.arcnum;++k)
	{        		//输入各边，构造邻接表
		VerTexType v1 , v2;
		int i , j;

		cin >> v1 >> v2;                 		//输入一条边依附的两个顶点
		i = LocateVex(G, v1);  j = LocateVex(G, v2);
		//确定v1和v2在G中位置，即顶点在G.vertices中的序号 

		ArcNode *p2=new ArcNode;                //生成另一个对称的新的边结点*p2 
		p2->adjvex=j;                   		//邻接点序号为i 
		p2->nextarc= G.vertices[i].firstarc;  
		G.vertices[i].firstarc=p2;  
		//将新结点*p2插入顶点vj的边表头部 
		ArcNode *p1=new ArcNode;                //生成另一个对称的新的边结点*p2 
		p1->adjvex=i;                   		//邻接点序号为i 
		p1->nextarc= G.vertices[j].firstarc;  
		G.vertices[j].firstarc=p1;  
		//将新结点*p1插入顶点vi的边表头部 
    }//for 
    return OK; 
}//CreateUDG

bool visited[MVNum];
int PathLenK(ALGraph G, VerTexType v, VerTexType w, int k)
{	
   /**********************Begin*******************/
    int i = LocateVex(G,v),j = LocateVex(G,w);

    if(i==j&&k==0) return 1;
	else if(k>0) 
	{
		visited[i]=1; 
		for(ArcNode *p=G.vertices[i].firstarc;p;p=p->nextarc) 
		{
			int l = p->adjvex; 
			if(!visited[l] && PathLenK(G,G.vertices[l].data,w,k-1)) return 1;
		}
		visited[i]=0;
	}
	return 0;
   /**********************End*******************/
}
void show(ALGraph G)
{
	for(int i = 0 ; i < G.vexnum ; ++i)
	{
		VNode temp = G.vertices[i];
		ArcNode *p = temp.firstarc;
		if(p == NULL)
		{
			cout << G.vertices[i].data;
			cout << endl;
		}
		else
		{
			cout << temp.data;
			while(p)
			{
				cout << "->";
				cout << G.vertices[p->adjvex].data;
				p = p->nextarc;
			}
		}
		cout << endl;
	}	
}

int main()
{
	ALGraph G;
	CreateUDG(G);

	int k;
    VerTexType m, n;
    cin >> m >> n >> k;
    
    cout << PathLenK(G, m, n, k);
	
	return 0;
}//main

头歌作业
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言练习题-最短路径.c
07-17
營火晚會上，所有同學任選一條長度1～40...圈，0號同學到2號同學距離為 20+30=50。但0號同學到4號同學最短距離為25+15+20+10=70。而0號同學所有其他同學 (0號到7號)的最短距離分別為0, 20, 30, 20, 70, 60, 40, 25。
DFS非递归实现搜索图中两顶点间的所有路径
naturerun的博客
12-11 1536
搜索无向图或有向图中两顶点间的所有最短路径应当使用DFS，配以适当的回溯操作即可实现路径搜索，具体代码如下，完全使用非递归方法实现 #include <iostream> #include <vector> #include <stdio.h> #include <malloc.h> #define N 6 //无环单边非负权重无向图顶点数 using namespace std; struct Path //路径节点结构体类型 { in
图的dfs非递归_搜索思想——DFS & BFS（基础篇）
weixin_39546747的博客
12-05 133
2019.4.20 时隔两年，重新修改了一下，加入一些现在的理解。上篇文章简单介绍了两种搜索思想的概念，在了解了最基础的概念之后，让我们先通过一些简单的题目实战了解下，再来总结获得的感悟我们先从最基本的图形问题说起题目一： 有一个长为N,宽为M的花园，在一次下雨后，花园里面出现了许多水洼，水洼的形状如图所示（‘。’代表土地，‘w’代表水洼，8个方向的水洼都视为联通，属于同一个）：。。。。w ...
二叉树-DFS非递归算法（前/中/后序）「数据结构算法精讲」
BBBling的博客
05-28 1586
为了写测试代码，首先需要创建一颗二叉树。 节点定义： typedef struct BTNode // 定义二叉树的节点 { char data; // 节点数据类型 struct BTNode *lchild; // 左孩子 struct BTNode *rchild; // 右孩子 }BTNode; 前序递归创建二叉树： BTNode *createBinaryTree() // 前序递归创建二叉树 { BTNode *p; char ch; cin &
数据结构---第六章图---图的应用---选择题
programmer9的博客
08-03 2051
数据结构---第六章图---图的应用---选择题
DFS非递归算法
Fairy
09-29 8474
DFS非递归算法
DFS非递归
u014204761的博客
10-02 1020
def DFS(root): # 非递归DFS ''' 利用栈完成非递归 1 初始化根节点，标记为访问过，入栈 2 取栈顶元素不出栈： 如果该元素有未访问的邻接点，访问该邻接点，入栈， 如果该元素所有邻接点都被访问或没有邻接点，出栈 ''' ...
数据结构习题——DFS非递归/判断一个无向图G是否为一颗树
无由页的博客
05-03 922
前言 日常输出一些题目 正文 题目一： 编写DFS非递归 void unrc_DFS(ALGraph G,int v){ ArcNode *p; initStack(s); visited[v]=true; push(s,v); while(!isEmpty(s)){ pop(s,p);visit(p);//弹出栈顶结点并访问 p=G.vertices[v].firstarc ...
C语言练习题-回圈上的最短路径.pdf
07-17
問題簡述： 營火晚會上，所有同學任選一條長度1～40不等的繩索，圍成一個圓圈以進行活動。其中一個活動為目測某位同學到 所有同學的最短距離，也就是串連該同學與其他同學的最短繩索長度。例如在下列圖中，8 位同學...
最短路径问题专项练习题.doc
10-08
最短路径问题专项练习题.doc
实验7简单路径和最短路径.cpp
11-22
实验7简单路径和最短路径.cpp
有向图中简单路径计数及最短路径最长路径的输出
11-16
可进行有向图的创建，所有简单路径的遍历，并找出其中的最短路径和最长路径。
《最短路径问题》练习题.doc
09-30
《最短路径问题》练习题.doc
最短路径问题
07-17
详细描述了解决最短路径问题的方法，包括：Dijkstra算法，Bellman-Ford算法 SPFA算法，以及一些习题。
【算法基础实验】图论-UnionFind连通性检测之quick-find
Greyplayground
04-26 1273
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
【算法基础实验】图论-UnionFind连通性检测之quick-union
Greyplayground
04-26 1282
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
c++图论基础(2)
2301_79249663的博客
04-26 701
当数据中0较多，比较占用内存空间，可以考虑用邻接表。每一行第一列表示的是最外层vector数组的下标。用来计算顶点的入度和出度,入度看行，出度看列。无向图的邻接矩阵是对称的，2是自环。
【算法基础实验】图论-深度优先搜索和深度优先路径
Greyplayground
04-26 1116
深度优先搜索是一个递归的过程，它尝试深入到每一个分支直到不能再深入为止，然后通过回溯继续探索其他分支。它的核心在于尝试所有可能的路径直到找到解决方案或覆盖所有的节点。DFS 的记忆点在于它的递归性质和回溯机制，这使得它非常适合处理需要探索所有可能性的问题。
【算法基础实验】图论-构建加权无向图
最新发布
Greyplayground
04-27 837
在图论中，加权无向图是一种每条边都分配了一个权重或成本的图形结构。这种类型的图在许多实际应用中都非常有用，如路由算法、网络流量设计、最小生成树和最短路径问题等。加权无向图的研究和应用提供了一种强大的工具，可以解决实际中的许多优化和规划问题。在算法和数据结构的领域中，理解并有效使用这些工具是非常重要的。
算法导论 习题24.2-4 & 24.3-6 单源最短路径问题
05-30
我们可以从这个简单环中删除任意一条边，得到一条从$s$到$v$的路径，路径长度比原来的最短路径长度更小，这与原来的最短路径的假设相矛盾。因此，假设不成立，结论得证。 --- 对于习题24.3-6，我们需要证明：如果...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值