C++ Dijkstra算法

上面写到了prim算法,细心的应该已经发现了,prim只能用于无向图的最小生成树,这是由于prim优先选择一边,而在出现相同权值时,选择靠"左"的点,在有向图中,可能是相等后靠“右”的点离目标点更近。照理来说,无向图最小生成树,若不出现上述情况,即不出现权值相等的边,最小生成树上的点,即是树上任意一点到根节点的最短路径,但最小生成树是所有权值和最小,即prim算法本身对于无向图是不存在任何问题的。Dijkstra算法用记录每个点的权值和来解决了这两个问题,即可用来生成有向图的最短路径,以下源码还是用邻接矩阵实现,邻接表实现更容易,只在prim算法上稍作修改即可


#include<iostream>
#define MAX_VERTEX 100
#define INFINITE 65535
using namespace std;
//array 
struct Vertex{
	char data;
	int mark;	
};

Vertex vertex_infos[MAX_VERTEX];
int matrix[MAX_VERTEX][MAX_VERTEX];
//common
int weight_array[MAX_VERTEX];
int vertex_parent[MAX_VERTEX];
int main(){
	 for(int i=0;i<MAX_VERTEX;i++){
    	vertex_parent[i]=0;
        weight_array[i]=INFINITE;
    }
	for(int i=0;i<MAX_VERTEX;i++){ 
        vertex_infos[i].data=0;
        vertex_infos[i].mark=0;
        for(int j=0;j<MAX_VERTEX;j++){ 
            matrix[i][j]=INFINITE; 
            matrix[i][j]=INFINITE; 
        } 
    }
     
    cout<<"input vertex and side nums:"; 
    int num_vertex; 
    int num_side; 
    cin>>num_vertex>>num_side; 
     
    cout<<"input vertex char data:"; 
    for(int i=0;i<num_vertex;i++){ 
        cin>>vertex_infos[i].data; 
    } 
     
    for(int i=0;i<num_side;i++){ 
        int v1; 
        int v2; 
        int weight;
        cout<<"input two vertex:"; 
        cin>>v1>>v2; 
        cout<<"input weight:"; 
        cin>>weight; 
        matrix[v1][v2]=weight;
        matrix[v2][v1]=weight;
    }
    
    
    //start from v0
    for(int i=1;i<MAX_VERTEX;i++){
    	if(vertex_infos[i].data==0){
	    	break;
	    }
        weight_array[i]=matrix[0][i];
    }
    for(int i=1;i<MAX_VERTEX;i++){
    	if(vertex_infos[i].data	==0){
	    	break;
	    }
        int k=0;
		int min=INFINITE;
		for(int j=1;j<MAX_VERTEX;j++){
			if(!vertex_infos[j].mark&&weight_array[j]<min){
				min=weight_array[j];
				k=j;
			}
		}

		vertex_infos[k].mark=1;
		
		for(int j=1;j<MAX_VERTEX;j++){
			if(!vertex_infos[j].mark&&matrix[k][j]+min<weight_array[j]){
				weight_array[j]=min+matrix[k][j];
				vertex_parent[j]=k;
			}
		}
    }
    for(int i=0;i<MAX_VERTEX;i++){
    	if(vertex_infos[i].data	==0){
	    	break;
	    }
    	cout<<vertex_parent[i];
    }
    cout<<endl;
	return 0;
}


  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Dijkstra算法是一种用于解决单源最短路径问题的经典算法,它可以找到从一个顶点到其他所有顶点的最短路径。下面是C++中实现Dijkstra算法的基本步骤: 1. 创建一个距离数组dist[],用于存储从源顶点到其他顶点的最短距离。初始化dist[]数组,将源顶点的距离设置为0,其他顶点的距离设置为无穷大。 2. 创建一个优先队列(最小堆)minHeap,用于选择下一个要访问的顶点。将源顶点加入minHeap,并将其距离设置为0。 3. 循环执行以下步骤,直到minHeap为空: a. 从minHeap中取出距离最小的顶点u。 b. 遍历u的所有邻接顶点v,计算从源顶点到v的距离newDist。如果newDist小于dist[v],则更新dist[v]为newDist,并将v加入minHeap。 4. 最终,dist[]数组中存储了从源顶点到所有其他顶点的最短距离。 下面是一个简单的C++代码示例: ```cpp #include <iostream> #include <vector> #include <queue> #include <climits> using namespace std; void dijkstra(vector<vector<pair<int, int>>>& graph, int source, vector<int>& dist) { int n = graph.size(); dist.resize(n, INT_MAX); dist[source] = 0; priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> minHeap; minHeap.push({0, source}); while (!minHeap.empty()) { int u = minHeap.top().second; minHeap.pop(); for (auto& neighbor : graph[u]) { int v = neighbor.first; int weight = neighbor.second; int newDist = dist[u] + weight; if (newDist < dist[v]) { dist[v] = newDist; minHeap.push({newDist, v}); } } } } int main() { int n = 5; // 顶点数 vector<vector<pair<int, int>>> graph(n); // 添加边 graph[0].push_back({1, 2}); graph[0].push_back({2, 4}); graph[1].push_back({2, 1}); graph[1].push_back({3, 7}); graph[2].push_back({3, 3}); graph[2].push_back({4, 5}); graph[3].push_back({4, 2}); int source = 0; // 源顶点 vector<int> dist; dijkstra(graph, source, dist); // 输出最短路径 for (int i = 0; i < n; i++) { cout << "Distance from source to vertex " << i << ": " << dist[i] << endl; } return 0; } ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值