C语言数组地图求最近距离

问题:假设有一张地图,上面有着阻碍物,入口,出口。求出入口到出口的最短距离

在数组中是这样的:有一个8*8的数组,1障碍物 0路 3入口 4出口

1 1 1 1 1 1

1 3 1 1 1 1

1 0 0 0 0 1

1 1 0 0 1 1

1 1 1 0 1 1

1 1 1 0 4 1

这样的话输出:7

程序思路与步骤:一开始出入一个值赋值为i,再输入一个i*i的地图

因为i是变量,无法创建动态数组,所以我们建一个100*100的数组,在for循环中限制它的赋值范围

 

重要思路:

1.以3为始发点,遍历它上下左右的数,然后判断是否为路,若为路,则路的那个0变为5,

2.然后执行第二步,遍历数组,将所有的5变为3,在执行第一步

这样的话他会以水波类型的那种形式便利整个地图,然而,怎么判断出口呢

我们先创建一个整型变量ok,默认为0;在main方法中加一个while循环执行1,2,这样:while(i!=1)

当3周围有出口4的时候,将ok变为1,循环结束

而最后的输出距离,则是有一个整型变量=0,在每次执行完2步骤时+1即可

代码:

/**
*莫言情难忘 1179307527
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
int n;
int ok=0;
int shu=0;
int shuzu[100][100];
void five(){
	for(int i=0;i<n;i++){
		for(int j=0;j<n;j++){
		if(shuzu[i][j]==5)
			shuzu[i][j]=3;
		}
	}
}
void three(int i,int j)
{

	//上
		if(shuzu[i-1][j]==4)
			ok=1;
		if(i>=0 && shuzu[i-1][j]==0){
			shuzu[i-1][j]=5;	
		}
	//下
		if(shuzu[i+1][j]==4)
			ok=1;
		if(i<n+1 && shuzu[i+1][j]==0){

			shuzu[i+1][j]=5;
			
		}

	//左
		if(shuzu[i][j-1]==4)
			ok=1;
		if(j>=0 && shuzu[i][j-1]==0){	
			
			shuzu[i][j-1]=5;
		
		}
	//右
		if(shuzu[i][j]==4)
		{ok=1;}
		if(j<n+1 && shuzu[i][j+1]==0){	
			shuzu[i][j+1]=5;
		}

}

int main(){
	int i,j,p,q=0;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	{
		for(j=0;j<n;j++)
		{
			scanf("%d",&shuzu[i][j]);
		}
	}
	for(i=0;i<n;i++)//初始值
	{
		for(j=0;j<n;j++)
		{
			if(shuzu[i][j]==3)
			{
			p=i;q=j;}
		}
	}

while(ok!=1){
	for(int t=0;t<n;t++){
		for(int v=0;v<n;v++){
		if(shuzu[t][v]==3)
			three(t,v);	
		}
	}
	five();
	shu++;
}
printf("%d",shu);
    return 0;
}
 

 

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
这里提供一种基于Dijkstra算法最短路径的C语言实现,以自定义网格为输入。代码如下: ```c #include <stdio.h> #include <stdlib.h> #include <limits.h> #define ROW 5 // 网格行数 #define COL 5 // 网格列数 struct Node { int row, col; // 节点坐标 int dist; // 起点到该节点的距离 int visited; // 是否已访问 struct Node* prev; // 最短路径中该节点的前驱节点 }; struct Node* create_node(int row, int col, int dist, struct Node* prev) { struct Node* node = (struct Node*)malloc(sizeof(struct Node)); node->row = row; node->col = col; node->dist = dist; node->visited = 0; node->prev = prev; return node; } int min_distance(struct Node* nodes[]) { int min_dist = INT_MAX; struct Node* min_node = NULL; for (int i = 0; i < ROW; i++) { for (int j = 0; j < COL; j++) { if (!nodes[i][j].visited && nodes[i][j].dist < min_dist) { min_dist = nodes[i][j].dist; min_node = &nodes[i][j]; } } } return min_node ? min_node->row * COL + min_node->col : -1; } void dijkstra(int grid[ROW][COL], int start_row, int start_col, int end_row, int end_col) { struct Node* nodes[ROW]; for (int i = 0; i < ROW; i++) { nodes[i] = (struct Node*)malloc(COL * sizeof(struct Node)); for (int j = 0; j < COL; j++) { nodes[i][j] = *create_node(i, j, INT_MAX, NULL); } } nodes[start_row][start_col].dist = 0; while (1) { int curr = min_distance(nodes); if (curr == -1) break; int curr_row = curr / COL, curr_col = curr % COL; nodes[curr_row][curr_col].visited = 1; if (curr_row == end_row && curr_col == end_col) break; for (int i = -1; i <= 1; i++) { for (int j = -1; j <= 1; j++) { if (i == 0 && j == 0) continue; int neighbor_row = curr_row + i, neighbor_col = curr_col + j; if (neighbor_row < 0 || neighbor_row >= ROW || neighbor_col < 0 || neighbor_col >= COL) continue; if (grid[neighbor_row][neighbor_col] == 0) continue; int alt = nodes[curr_row][curr_col].dist + grid[neighbor_row][neighbor_col]; if (alt < nodes[neighbor_row][neighbor_col].dist) { nodes[neighbor_row][neighbor_col].dist = alt; nodes[neighbor_row][neighbor_col].prev = &nodes[curr_row][curr_col]; } } } } if (nodes[end_row][end_col].dist == INT_MAX) { printf("No path found.\n"); } else { printf("Shortest path distance: %d\n", nodes[end_row][end_col].dist); printf("Shortest path: "); struct Node* curr = &nodes[end_row][end_col]; while (curr) { printf("(%d,%d) ", curr->row, curr->col); curr = curr->prev; } printf("\n"); } for (int i = 0; i < ROW; i++) { free(nodes[i]); } } int main() { int grid[ROW][COL] = { {1, 2, 3, 4, 5}, {1, 0, 1, 0, 1}, {1, 1, 1, 1, 1}, {0, 0, 0, 1, 0}, {1, 1, 1, 1, 1} }; dijkstra(grid, 0, 0, 4, 4); return 0; } ``` 该代码首先定义了一个Node结构体表示网格中的节点,包含节点的坐标、从起点到该节点的距离、是否已访问以及最短路径中该节点的前驱节点。create_node函数用于创建一个新的节点。min_distance函数用于在未访问的节点中查找距离起点最近的节点。dijkstra函数则是实现Dijkstra算法的核心函数,其中使用nodes数组存储所有节点的状态。首先将起点的距离设为0,然后循环查找未访问的节点中距离起点最近的节点,并将其标记为已访问。接着遍历该节点的所有邻居节点,如果邻居节点未访问且到起点的距离可以缩短,则更新邻居节点的状态。最后,如果终点已访问,则结束循环。如果终点未访问,则说明不存在从起点到终点的路径。最后释放nodes数组中的所有节点。 该代码针对一个5x5的网格进行了测试,其中1表示可通过的节点,0表示不可通过的节点。起点为(0,0),终点为(4,4)。运行结果如下: ``` Shortest path distance: 12 Shortest path: (4,4) (3,4) (2,4) (1,4) (0,4) (0,3) (0,2) (0,1) (0,0) ``` 可以看到,起点到终点的最短路径的长度为12,路径为(4,4) (3,4) (2,4) (1,4) (0,4) (0,3) (0,2) (0,1) (0,0)。 这个算法可以用于解决很多实际问题,比如地图导航、网络路由等。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值