地杰斯特拉算法邻接表版

#include<stdio.h>
#include<vector>
using namespace std;
const int inf=0xffffff;
struct node{
	int v,d;
};
vector <node> a[1005];//a[u]存放从顶点u出发可以到达的所有顶点 
int n,d[1005],vis[1005],m;
void dijkstra()
{
	int i,j,v;
	for(i=1;i<=n;i++)
	{
		int u,min=inf;
		for(j=1;j<=n;j++)
		{
			if(vis[j]==0&&d[j]<min)
			{
				u=j;
				min=d[j];
			}
		}
		vis[u]=1;
		for(j=0;j<a[u].size();j++)
		{
			v=a[u][j].v;
			if(vis[v]==0&&d[u]+a[u][j].d<d[v])
			{
				d[v]=d[u]+a[u][j].d;
			}
		}
	}
}
int main()
{
	int i,u,v,f;
while(~scanf("%d%d",&n,&m))
{
	for(i=0;i<105;i++)
	a[i].clear();
	fill(d,d+1005,inf);
	fill(vis,vis+1005,0);
	d[1]=0;
	if(n==0&&m==0)
	break;
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%d",&u,&v,&f);
		node t;
		t.v=v;t.d=f;
		a[u].push_back(t);
		t.v=u;t.d=f;
		a[v].push_back(t);
	}
	dijkstra();
	printf("%d\n",d[n]);
}
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我会尽力回答你的问题。 首先,我们需要了解什么是邻接表邻接表是一种表示图的数据结构,它使用链表来存储每个节点的邻居节点。在邻接表中,每个节点都有一个链表,其中存储了所有与该节点相邻的节点。 接下来,我们可以使用迪杰斯特拉算法来求解两个站点之间的最短路径。迪杰斯特拉算法是一种用于解决带权重图的单源最短路径问题的算法。该算法可以计算出从源节点到图中所有其他节点的最短路径。 下面是使用邻接表和迪杰斯特拉算法求解两个站点最短路径的C语言代码: ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAX_NODES 1000 #define INF 99999 // 邻接表节点结构体 typedef struct AdjListNode { int dest; int weight; struct AdjListNode* next; } AdjListNode; // 邻接表结构体 typedef struct AdjList { AdjListNode* head; } AdjList; // 图结构体 typedef struct Graph { int V; AdjList* array; } Graph; // 新建邻接表节点 AdjListNode* newAdjListNode(int dest, int weight) { AdjListNode* newNode = (AdjListNode*)malloc(sizeof(AdjListNode)); newNode->dest = dest; newNode->weight = weight; newNode->next = NULL; return newNode; } // 新建图 Graph* createGraph(int V) { Graph* graph = (Graph*)malloc(sizeof(Graph)); graph->V = V; graph->array = (AdjList*)malloc(V * sizeof(AdjList)); for (int i = 0; i < V; ++i) { graph->array[i].head = NULL; } return graph; } // 添加边 void addEdge(Graph* graph, int src, int dest, int weight) { AdjListNode* newNode = newAdjListNode(dest, weight); newNode->next = graph->array[src].head; graph->array[src].head = newNode; newNode = newAdjListNode(src, weight); newNode->next = graph->array[dest].head; graph->array[dest].head = newNode; } // 打印解决方案 void printSolution(int dist[], int n) { printf("Vertex\tDistance from Source\n"); for (int i = 0; i < n; ++i) { printf("%d\t\t%d\n", i, dist[i]); } } // 找到距离最小的节点 int minDistance(int dist[], bool sptSet[], int V) { int min = INF, min_index; for (int v = 0; v < V; ++v) { if (sptSet[v] == false && dist[v] <= min) { min = dist[v]; min_index = v; } } return min_index; } // 使用迪杰斯特拉算法求解最短路径 void dijkstra(Graph* graph, int src, int dest) { int dist[MAX_NODES]; bool sptSet[MAX_NODES]; // 初始化距离和sptSet for (int i = 0; i < graph->V; ++i) { dist[i] = INF; sptSet[i] = false; } dist[src] = 0; for (int count = 0; count < graph->V - 1; ++count) { int u = minDistance(dist, sptSet, graph->V); sptSet[u] = true; for (AdjListNode* v = graph->array[u].head; v != NULL; v = v->next) { if (!sptSet[v->dest] && dist[u] != INF && dist[u] + v->weight < dist[v->dest]) { dist[v->dest] = dist[u] + v->weight; } } } if (dist[dest] != INF) { printf("The shortest path from %d to %d is: %d\n", src, dest, dist[dest]); } else { printf("There is no path from %d to %d\n", src, dest); } } int main() { Graph* graph = createGraph(6); addEdge(graph, 0, 1, 4); addEdge(graph, 0, 2, 3); addEdge(graph, 1, 2, 1); addEdge(graph, 1, 3, 2); addEdge(graph, 2, 3, 4); addEdge(graph, 3, 4, 2); addEdge(graph, 4, 5, 6); dijkstra(graph, 0, 5); return 0; } ``` 在这个例子中,我们创建了一个包含6个节点的图,并且使用addEdge函数添加了边。然后,我们调用了dijkstra函数来计算从源节点0到目标节点5之间的最短路径。 希望这个代码能够解决你的问题!

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值