人工智能经典题目，罗马尼亚问题，C语言版，贪婪算法和启发式算法

最新推荐文章于 2024-07-14 18:15:43 发布
最新推荐文章于 2024-07-14 18:15:43 发布
阅读量616 收藏 8
点赞数 1
分类专栏： C语言程序设计 人工智能 数据结构 文章标签： 启发式算法 算法 人工智能 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AABond/article/details/127455381
版权

贪心算法 启发式搜索 A*算法 城市旅行问题 路径优化
关键词由CSDN通过智能技术生成

一、问题描述

        看图说话，问题很简单。

 二、迟来的代码

        贪婪算法

#include <stdio.h>
#include <stdlib.h>

#define N 	21	// 城市个数
#define MaxInt 32768	// 定义无穷大

// 枚举城市名，给城市名从0开始编码，相当于"#define Arad 0"，
enum City{Arad = 0, Bucharest, Craiova, Dobreta, Eforie, 
			Fagaras, Giurgiu, Hirsova,Iasi, Lugoj, Mehadia, 
			Neamt, Oradea, Pitesti, Rimnicu_Vilcea, 
			Sibiu, Timisoara,Urziceni, Vaslui, Zerind};

int arcs[N][N] = {0};		// 定义两个城市间实际距离

// 定义两个城市间的直线距离，即最短距离，小于等于实际距离
int line[N] = {366, 0, 160, 242, 161, 176, 77, 151, 226, 244,
				241, 234, 380, 10, 193, 253, 329, 80, 199, 374};	

// 初始化问题状态
void init()
{
	// 定义两个城市间的距离
	{
		arcs[Zerind][Oradea] = 71;
		arcs[Zerind][Arad] = 75;
		arcs[Arad][Sibiu] = 140;
		arcs[Arad][Timisoara] = 118;
		arcs[Oradea][Sibiu] = 151;
		arcs[Timisoara][Lugoj] = 111;
		arcs[Lugoj][Mehadia] = 70;
		arcs[Mehadia][Dobreta] = 75;
		arcs[Dobreta][Craiova] = 120;
		arcs[Sibiu][Fagaras] = 99;
		arcs[Sibiu][Rimnicu_Vilcea] = 80;
		arcs[Rimnicu_Vilcea][Pitesti] = 97;
		arcs[Rimnicu_Vilcea][Craiova] = 146;
		arcs[Craiova][Pitesti] = 138;
		arcs[Pitesti][Bucharest] = 101;
		arcs[Fagaras][Bucharest] = 211;
		arcs[Bucharest][Giurgiu] = 90;
		arcs[Bucharest][Urziceni] = 85;
		arcs[Urziceni][Hirsova] = 98;
		arcs[Hirsova][Eforie] = 86;
		arcs[Urziceni][Vaslui] = 142;
		arcs[Vaslui][Iasi] = 92;
		arcs[Iasi][Neamt] = 87;
	}
	
	int i, j;

	// 初始化剩下城市的距离，相同两个城市间距离定义为0
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			// 如果两个城市之间可以直达，即图中两个城市节点之间的边
			if(arcs[i][j] > 0)
			{
				arcs[j][i] = arcs[i][j];
			}
			else if(arcs[j][i] > 0)
			{
				arcs[i][j] = arcs[j][i];
			}
			// 无法直接到达的两个城市之间的距离为-1
			
			else if(i == j)
			{
				arcs[i][j] = 0;
			}
			else 
			{
				arcs[i][j] = -1;
			}
		}
	}
}

// 根据城市编码转换成城市名
void transform(int city)
{
	switch(city)
	{
		case Arad:
			printf("%s\n", "Arad");
			break;
		case Bucharest:
			printf("%s\n", "Bucharest");
			break;
		case Craiova:
			printf("%s\n", "Craiova");
			break;
		case Dobreta:
			printf("%s\n", "Dobreta");
			break;
		case Eforie: 
			printf("%s\n", "Eforie");
			break;
		case Fagaras:
			printf("%s\n", "Fagaras");
			break;
		case Giurgiu:
			printf("%s\n", "Giurgiu");
			break;
		case Hirsova:
			printf("%s\n", "Hirsova");
			break;
		case Iasi:
			printf("%s\n", "Iasi");
			break; 
		case Lugoj:
			printf("%s\n", "Lugoj");
			break;
		case Mehadia:
			printf("%s\n", "Arad");
			break; 
		case Neamt:
			printf("%s\n", "Neamt");
			break;
		case Oradea:
			printf("%s\n", "Oradea");
			break;
		case Pitesti:
			printf("%s\n", "Pitesti");
			break;
		case Rimnicu_Vilcea:
			printf("%s\n", "Rimnicu Vilcea");
			break;
		case Sibiu:
			printf("%s\n", "Sibiu");
			break;
		case Timisoara:
			printf("%s\n", "Timisoara");
			break;
		case Urziceni:
			printf("%s\n", "Urziceni");
			break;
		case Vaslui:
			printf("%s\n", "Vaslui");
			break;
		case Zerind:
			printf("%s\n", "Zerind");
			break;
	}
}

// 打印解的路径
void show(int *Path)
{
	int i;
	printf("解的路径如下\n");

	for(i = 0; Path[i] != -1; i++)
	{	
		transform(Path[i]);	// 打印当前节点
	}
}

// 贪婪算法
void Greedy(int V0, int VN)
{
	printf("start Greedy\n");

	int i, v, w, min, cost;

	int S[N];	// 记录从源点V0到终点Vi是否已被确定为最短路径长度
	int Path[N];	// 记录从源点V0到终点Vi的当前最短路径长度上Vi的直接前驱节点号

	// 初始化解的路径，-1表示为节点没在路径，n表示n对应的城市在路径中
	for(i = 0; i < N; i++)
	{
		S[i] = 0;
		Path[i] = -1;
	}

	cost = 0;
	S[V0] = 1;	// 标记初始节点已经加入解的路径中
	Path[0] = V0;	// 把初始节点加入解的路径中

	// 最多需要搜索N次，如果都没有找到，就直接结束，一般这种情况不会发生
	for(i = 1; i < N; i++)
	{
		v = V0;
		min = MaxInt;
		
		// 从剩下的未标记的，是当前的节点的后继节点中的节点中
		// 选出一个离目标的节点的距离最小的，作为下次拓展的节点
		for(w = 0; w < N; w++)
		{
			if(!S[w] && arcs[Path[i-1]][w] > 0 && line[w] < min)
			{
				v = w;
				min = line[w];
			}
		}

		S[v] = 1;	// 标记已经选出的最小的节点
		Path[i] = v;	// 把选出的节点加入到解的路径中
		cost += arcs[Path[i-1]][v];	// 累加实际代价
		
		printf("本次拓展节点：");
		transform(v);
		printf("估价函数值：%d\n", line[v]);
		
		// 如果选出的节点就是目标节点，结束
		if(Path[i] == VN)
		{
			printf("Greedy finsih\n\n");
			show(Path);
			printf("实际的总代价：%d\n", cost);
			break;
		}
	}
}

int main(void)
{
	init();

	Greedy(Zerind, Bucharest);

	return 0;
}

       

启发式算法

#include <stdio.h>
#include <stdlib.h>

#define N 	21	// 城市个数
#define MaxInt 32768	// 定义无穷大

// 枚举城市名，给城市名从0开始编码，相当于"#define Arad 0"，
enum City{Arad = 0, Bucharest, Craiova, Dobreta, Eforie, 
			Fagaras, Giurgiu, Hirsova,Iasi, Lugoj, Mehadia, 
			Neamt, Oradea, Pitesti, Rimnicu_Vilcea, 
			Sibiu, Timisoara,Urziceni, Vaslui, Zerind};

int arcs[N][N] = {0};		// 定义两个城市间的距离

// 定义两个城市间的直线距离，即最短距离，小于等于实际距离
int line[N] = {366, 0, 160, 242, 161, 176, 77, 151, 226, 244,
				241, 234, 380, 10, 193, 253, 329, 80, 199, 374};

int g[N] = {0};	// 从初始节点到当前节点的代价

// 初始化问题状态
void init()
{
	// 定义两个城市间的距离
	{
		arcs[Zerind][Oradea] = 71;
		arcs[Zerind][Arad] = 75;
		arcs[Arad][Sibiu] = 140;
		arcs[Arad][Timisoara] = 118;
		arcs[Oradea][Sibiu] = 151;
		arcs[Timisoara][Lugoj] = 111;
		arcs[Lugoj][Mehadia] = 70;
		arcs[Mehadia][Dobreta] = 75;
		arcs[Dobreta][Craiova] = 120;
		arcs[Sibiu][Fagaras] = 99;
		arcs[Sibiu][Rimnicu_Vilcea] = 80;
		arcs[Rimnicu_Vilcea][Pitesti] = 97;
		arcs[Rimnicu_Vilcea][Craiova] = 146;
		arcs[Craiova][Pitesti] = 138;
		arcs[Pitesti][Bucharest] = 101;
		arcs[Fagaras][Bucharest] = 211;
		arcs[Bucharest][Giurgiu] = 90;
		arcs[Bucharest][Urziceni] = 85;
		arcs[Urziceni][Hirsova] = 98;
		arcs[Hirsova][Eforie] = 86;
		arcs[Urziceni][Vaslui] = 142;
		arcs[Vaslui][Iasi] = 92;
		arcs[Iasi][Neamt] = 87;
	}
	
	int i, j;
	for(i = 0; i < N; i++)
	{
		for(j = 0; j < N; j++)
		{
			if(arcs[i][j] > 0)
			{
				arcs[j][i] = arcs[i][j];
			}
			else if(arcs[j][i] > 0)
			{
				arcs[i][j] = arcs[j][i];
			}
			else if(i != j)
			{
				arcs[i][j] = MaxInt;
				arcs[j][i] = MaxInt;
			}
		}
	}
}

// 转换成城市名
void transform(int city)
{
	switch(city)
	{
		case Arad:
			printf("%s\n", "Arad");
			break;
		case Bucharest:
			printf("%s\n", "Bucharest");
			break;
		case Craiova:
			printf("%s\n", "Craiova");
			break;
		case Dobreta:
			printf("%s\n", "Dobreta");
			break;
		case Eforie: 
			printf("%s\n", "Eforie");
			break;
		case Fagaras:
			printf("%s\n", "Fagaras");
			break;
		case Giurgiu:
			printf("%s\n", "Giurgiu");
			break;
		case Hirsova:
			printf("%s\n", "Hirsova");
			break;
		case Iasi:
			printf("%s\n", "Iasi");
			break; 
		case Lugoj:
			printf("%s\n", "Lugoj");
			break;
		case Mehadia:
			printf("%s\n", "Arad");
			break; 
		case Neamt:
			printf("%s\n", "Neamt");
			break;
		case Oradea:
			printf("%s\n", "Oradea");
			break;
		case Pitesti:
			printf("%s\n", "Pitesti");
			break;
		case Rimnicu_Vilcea:
			printf("%s\n", "Rimnicu Vilcea");
			break;
		case Sibiu:
			printf("%s\n", "Sibiu");
			break;
		case Timisoara:
			printf("%s\n", "Timisoara");
			break;
		case Urziceni:
			printf("%s\n", "Urziceni");
			break;
		case Vaslui:
			printf("%s\n", "Vaslui");
			break;
		case Zerind:
			printf("%s\n", "Zerind");
			break;
	}
}

// 打印解的路径
void show(int *Path)
{
	int i;
	printf("解的路径如下\n");

	for(i = 0; Path[i] != -1; i++)
	{	
		transform(Path[i]);	// 打印当前节点
	}

}

// 启发式算法
void Astar(int V0, int VN)
{
    printf("Astar start\n");
    int i, v, w, min, cost;
    
	int S[N];	// 记录从源点V0到终点Vi是否已被确定为最短路径长度
	int Path[N];	// 记录从源点V0到终点Vi的当前最短路径长度上Vi的直接前驱节点号

    for(i = 0; i < N; i++)
    {
		S[i] = 0;	// 初始时所有节点都没有被加入解路径
        Path[i] = -1;	// 初始化解的路径
        g[i] = arcs[V0][i];	// 初始化节点到当前节点的代价
    }
    
	cost = 0;
    S[V0] = 1;	// 标记已经选出的最小的节点
    Path[0] = V0;	// 把选出的节点加入到解的路径中
    
    for(i = 1; i < N; i++)
    {
        v = V0;
		min = MaxInt;

		// 从不在解的路径中的节点组成的节点集和当前节点的后继节点的组成的节点集的交集中
		// 选择出估计函数最小的节点，作为下一个要拓展的节点
		for(w = 0; w < N; w++)
		{
			if(!S[w]  && arcs[Path[i-1]][w] > 0 && arcs[Path[i-1]][w] < MaxInt)
			{
				if(g[w]+ line[w] < min)
				{  
					v = w;
					min = g[w]+ line[w];
				}
				
			} 
		}

		S[v] = 1;	// 标记已经选出的最小的节点
		Path[i] = v;	// 把选出的节点加入到解的路径中

		printf("本次拓展节点：");
        transform(v);
		printf("估计函数值：%d\n", min);

		cost += arcs[Path[i-1]][v];	// 累加实际代价

		// 更改当前节点到剩下不在解的路径中的代价
		// 这里直接修改，不需要比较g[w] 与 g[v] + arcs[v][w]的大小
		// 这里这里没有采用open表和close表，所以为了避免回溯的问题，直接修改
		for(w = 0; w < N; w++)
		{
			if(!S[w])
			{
				g[w] = g[v] + arcs[v][w];
			}
		}
        
		// 如果选出的节点就是目标节点，结束
        if(Path[i] == VN)
        {
            printf("Astar finish\n\n");
            show(Path);
			printf("总共的代价：%d\n", cost);
            break;
        }
    }
}

int main(void)
{
	init();

	Astar(Zerind, Bucharest);

	return 0;
}

三、简单分析

        相信认真看完代码注释的程序猿同学，应该能看懂了，这里的采用的启发式搜索进行了一点点改进，是更加实际情况而定，注释也有说明。

        此外特别想说明一下，这个题，最复杂的就是如何表示城市名了，因为要打印解的路径码，所以要对城市名进行编码，然后输出时，又进行译码，这种方法对解决某些类似的问题特别有效！这里采用了枚举的方法来进行编码，当然也可以采用#define 宏定义的方法，不过不建议采用，因为特别长。

        至于具体的流程图，这里不给出，因为太难画了，而且也相信别的博主的博客上也有，这里主要讲解代码的写法。

Great Macro
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
罗马尼亚问题
06-03
分别用宽度优先、深度优先、贪婪算法和 A*算法求解“罗马利亚度假问题”。 要求： 分别用文件存储地图和启发函数表，用生成节点数比较以上四种算法在同一问题求 解时的效率，列表给出结果。
人工智能——罗马利亚问题
Dedication_的博客
12-29 554
题目： 根据上图以Zerind为初始状态，Bucharest为目标状态实现搜索，分别以贪婪搜索（只考虑直线距离）和A算法求解最短路径。 按顺序列出贪婪算法探索的扩展节点和其估价函数值，A算法探索的扩展节点和其估计值。 题目解析： 1.构建罗马利亚图 2.构建到B城市的直线距离 3.实现贪婪算法 4.实现A*算法 5.对所求路径及总长度进行输出 代码： # 罗马利亚图存储 city_graph = [['A', 'Z', 75], ['A', 'T', 118],
人工智能报告-罗马尼亚度假问题及源代码
12-08
这是报告和源代码，分别用宽度优先、深度优先、贪婪算法和 A*算法求解“ 罗马利亚度假问题 ”（即最短路径的搜索问题）。要求：分别用文件存储地图和启发函数表，用生成节点数比较几种算法在问题求解时的效率，列表给出结果。（中国地质大学赵曼老师教！！！
人工智能导论罗马尼亚问题实验一搜索算法C++实现详解
weixin_44142358的博客
10-31 3501
人工智能导论搜索算法实验题目要求开始写代码之前的思考：建立图考虑深度优先搜索策略：功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 题目要求 一、实验目的 • 了解4种无信息搜索策略和2种有信息搜索策略的算法思想； • 能够运用计算
人工智能导论实验一搜索策略解决罗马尼亚问题六合一完整版
weixin_44142358的博客
10-31 928
分别解释请看博客的另一篇文章 该处只提供六合一代码的参考。 代码由博主手工码出，难免有错误和之处不严谨之处，请留言修改。 不建议直接复制使用。 #include<iostream> #include <functional> #include<stack> #include<vector> #include<queue> #include<memory.h> using namespace std; #define A 0 #defin
人工智能原理实验八数码问题和罗马尼亚问题（含代码和完整实验报告）启发性搜索和A*算法
12-28
人工智能实验八数码问题和罗马尼亚问题（含代码和完整实验报告） 本实验课程是计算机、智能、物联网等专业学生的一门专业课程，通过实验，帮助学生更好地掌握人工智能相关概念、技术、原理、应用等；通过实验提高...
基于PyQt实现可视化宽度优先、深度优先、贪婪算法和 A*算法解决罗马尼亚度假问题。
10-18
分别采用：宽度优先、深度优先、贪婪算法和A*算法实现罗马尼亚度假问题。主要程序分为画布以及功能区两个部分，其中功能区又具有通过深度优先搜索算法、广度优先算法、贪婪算法、 A* 算法搜索指定节点间最短路径的...
人工智能实验：搜索算法问题求解
02-08
• 应用搜索算法解决实际问题(如罗马尼亚问题)； • 学会对算法性能的分析和比较 二、实验的硬件、软件平台 硬件：计算机 软件：操作系统：WINDOWS／Linux 应用软件：C, Java或者MATLAB 三、实验内容及步骤 ...
基于搜索算法解决罗马尼亚度假问题（代码版）
03-04
本实验要求用广度优先算法、深度优先算法和A*算法求解“罗马尼亚度假问题”，即找到从初始地点 Arad 到目的地点 Bucharest 的一条最佳路径。
八皇后问题与罗马尼亚问题人工智能课程设计报告
06-21
八皇后问题与罗马尼亚问题人工智能课程设计报告知识点总结 一、八皇后问题 八皇后问题是一种经典的 Constraint Satisfaction Problem（约束满足问题），目标是在 N*N 的棋盘上摆放 N 个皇后，使得每个皇后都不会...
人工智能代码（罗马尼亚问题+n皇后问题）
11-08
赵老师的人工智能课程代码和报告
罗马尼亚问题,从Arad到Bucharest结果，深度优先搜索(DFS)；迭代加深的搜索(IDS)；A*搜索；一致代价搜索(UCS)；
04-19
罗马尼亚问题,从Arad到Bucharest结果，深度优先搜索(DFS)；迭代加深的搜索(IDS)；A*搜索；一致代价搜索(UCS)；java实现
[数据结构 & 算法] A*算法--罗马尼亚度假问题（实验课作业）
热门推荐
专注于计算机视觉与计算机图形学
04-27 1万+
问题表述 利用A*算法找到从A城市到B城市的最短路径，以及代价，其中A*算法中的h也就是从当前点到目标点的距离已经给出。 作为人工智能课程实验课的题目，给的帮助代码是纯C语言写的，连容器都是以头文件形式提供的，表示十分不能理解。以下是我用C++完成的实验代码，为了方便，所以定义都集中在一个cpp文件里 代码部分 注释已经很详细了 #include&lt;iostream&gt; ...
罗马尼亚旅游问题 贪婪最佳优先搜索 A*搜索【python】
Jing_HJY的博客
09-30 8238
文章目录一、问题描述二、贪婪最佳优先搜索和A*搜索的理解1.贪婪最佳优先搜索2.A*搜索算法三、A*搜索的代码1.A*搜索的思路2.A*搜索的代码四、结果与两种算法的对比 一、问题描述 在罗马尼亚旅游问题中，搜索从城市Arad出发到达Bucharest的路径。其中neighbor_map可以得到所需要的城市和哪些城市相邻，比如：Arad有三个邻居：Zerind，Sibiu，Timisora，由Arad到达这三个城市的代价可由以下字典neighbormapWithweight获得。城市的坐标由如下字典提供，
罗马尼亚度假问题 人工智能搜索算法全代码C++（深度优先，广度优先，等代价，迭代加深，有信息搜索，A*算法，贪婪算法）
W_yu_cheng的博客
04-26 1万+
深度优先，广度优先，等代价，迭代加深，有信息搜索，A*算法，贪婪算法
罗马尼亚度假问题和N皇后问题
geekcug的博客
11-11 4800
罗马利亚度假问题和N皇后问题及其主体代码
人工智能实验一：使用搜索算法实现罗马尼亚问题的求解
jzb的博客
03-10 1490
主要思想是利用一个估价函数f(n)来评估每个节点n的优先级，f(n)由两部分组成：g(n)表示从起点到节点n的实际代价，h(n)表示从节点n到终点的预估代价。，算法所采用的启发式搜索可以利用实际问题所具备的启发式信息来指导搜索，从而减少搜索范围，控制搜索规模，降低实际问题的复杂度。每次扩展完节点后都要对扩展集合里的节点进行一次优先级的排序，用于下一个循环来取出当前优先级最高的节点。如果邻居节点不在扩展集合中，则将其加入扩展集合中，记录父节点，并用list数组标记为在扩展集合中。
TSP问题——启发式算法求解
Dave_Young的博客
09-26 2324
旅行商TSP问题，遗传算法，模拟退火和贪婪算法求解。
LC53最大子数组和、lc5最长回文子串、lc283移动零
最新发布
m0_47536537的博客
07-14 188
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
宽度优先、贪婪算法和A*算法实现罗马尼亚度假问题 qt
03-14
宽度优先、贪婪算法和A*算法都可以用来解决罗马尼亚度假问题。其中，宽度优先算法会遍历所有可能的路径，直到找到最短路径；贪婪算法会选择当前看起来最优的路径，但不一定能找到最短路径；A*算法则是结合了宽度优先...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值