迪杰斯特拉/dijkstra 算法模板(具体凝视)

#include <iostream>
#include <malloc.h>
#include <cstring>
#include <stack>
#include <cstdio>

//定义邻接矩阵的大小
#define N 100
#define M 100

using namespace std;

typedef struct node {
    int map[N][M];//邻接矩阵
    int n;//顶点数
    int e;//边数
}MGragh;

void dijkstra(MGragh g,int *dis,int *pre,int v0){
    int i,j,k;
    bool *visited=(bool *)malloc(sizeof(bool)*g.n);//标记数组
    for(i=0;i<g.n;i++){//初始化
        if(g.map[v0][i]>0&&i!=0){
            dis[i]=g.map[v0][i];
            pre[i]=v0;
        }
        else{
            dis[i]=INT_MAX;
            pre[i]=-1;
        }
        pre[v0]=v0;
        dis[v0]=0;
    }
    visited[v0]=true;//标记源点v0为訪问过
    for(i=1;i<g.n;i++){//执行n-1次
        int min=INT_MAX;//初始化
        int u;
        for(j=0;j<g.n;j++){//寻找未訪问过的顶点中权值最小的那个
            if(visited[j]==false&&dis[j]<min){
                min=dis[j];//记录下来
                u=j;
            }
        }
        visited[u]=true;//标记为訪问过
        //更新dis数组的值和路径
        for(k=0;k<g.n;k++){
            if(visited[k]==false&&g.map[u][k]>0&&g.map[u][k]+min<dis[k]){
                dis[k]=min+g.map[u][k];
                pre[k]=u;
            }
        }
    }
}

void showpath(int *pre,int v,int v0){//v是当前节点。
    //输出源点v0到当前节点v的路径
    stack<int>s;
    while(v!=v0){
        s.push(v);
        v=pre[v];
    }
    s.push(v);
    while(!s.empty()){
        printf("%d ",s.top());
        s.pop();
    }
}

int main()
{
    int n,e;
    while(scanf("%d%d",&n,&e)&&e!=0){
        int i,j;
        int s,t,w;//起始点s,终点t,边st的权值为w
        MGragh g;
        int v0;//源点v0
        int *dis=(int *)malloc(sizeof(int)*n);//dis[i]记录从源点v0到当前点i的路径长度
        int *pre=(int *)malloc(sizeof(int)*n);//记录每一个点的前驱,即pre[i]=j;说明i点的前驱为j
        for(i=0;i<N;i++){//初始化
            for(j=0;j<M;j++){
                g.map[i][j]=0;
            }
        }
        g.n=n;
        g.e=e;
        for(i=0;i<e;i++){//建立邻接矩阵
            scanf("%d%d%d",&s,&t,&w);
            g.map[s][t]=w;
        }
        scanf("%d",&v0);

        dijkstra(g,dis,pre,v0);
        for(i=0;i<n;i++){
            if(i!=v0){
                showpath(pre,i,v0);//输出路径
                printf("%d\n",dis[i]);//输出最短路径的大小
            }
        }
    }
    return 0;
}
/*
測试用例
5 7
0 1 100
0 2 30
0 4 10
2 1 60
2 3 60
3 1 10
4 3 50
0
*/
时间: 2024-09-27 14:48:12

迪杰斯特拉/dijkstra 算法模板(具体凝视)的相关文章

迪杰斯特拉/dijkstra 算法模板(详细注释)

#include <iostream> #include <malloc.h> #include <cstring> #include <stack> #include <cstdio> //定义邻接矩阵的大小 #define N 100 #define M 100 using namespace std; typedef struct node { int map[N][M];//邻接矩阵 int n;//顶点数 int e;//边数 }MGr

43. 蛤蟆的数据结构笔记之四十三最短路径之迪杰斯特拉(Dijkstra )算法

43. 蛤蟆的数据结构笔记之四十三最短路径之迪杰斯特拉(Dijkstra )算法 本篇名言:"辛勤的蜜蜂永没有时间悲哀.--布莱克" 这次来看下Dijkstra )算法.还是老方法,先原理,后实现.代码来自网络. 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/47046031 1.  最短路径 最短路径问题是图论研究中的一个经典算法问题, 旨在寻找图(由结点和路径组成的)中两结点之间的最短路径. 管道铺设.线路安排

C# 迪杰斯特拉(Dijkstra)算法

Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止. 其基本思想是,设置顶点集合S并不断地作贪心选择来扩充这个集合.一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知. 初始时,S中仅含有源.设u是G的某一个顶点,把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径,并用数组dist记录当前每个顶点所对应的最短特殊路径长度.Dijkstra算法每次从V-S中取出具有最短特殊路长度

迪杰斯特拉(Dijkstra)算法

1 # include <stdio.h> 2 3 # define MAX_VERTEXES 20//最大顶点数 4 # define INFINITY 65535;//代表∞ 5 6 typedef struct 7 {/* 无向图结构体 */ 8 int vexs[MAX_VERTEXES];//顶点下标 9 int arc[MAX_VERTEXES][MAX_VERTEXES];//矩阵 10 int numVertexes, numEdges;//顶点数和边数 11 12 }MGra

[C++]单源最短路径:迪杰斯特拉(Dijkstra)算法(贪心算法)

1 Dijkstra算法 1.1 算法基本信息 解决问题/提出背景 单源最短路径(在带权有向图中,求从某顶点到其余各顶点的最短路径) 算法思想 贪心算法 按路径长度递增的次序,依次产生最短路径的算法 [适用范围]Dijkstra算法仅适用于[权重为正]的图模型中 时间复杂度 O(n^3) 补充说明 亦可应用于[多源最短路径](推荐:Floyd算法(动态规划,O(n^3))) Dijkstra 时间复杂度:O(n^3) 1.2 算法描述 1.2.1 求解过程(具体思路) 1.2.2 示例 1.2

迪杰斯特拉(Dijkstra)算法求最短路径

我用的是邻接矩阵来存储图的. 代码如下: void Graph:: Dijkstra(){ struct DijNode{ int index; int distance; vector<string> path; bool Founded; //判定是否找到了... }; DijNode*shorestPaths=new DijNode[mgraph.vexnum]; string startPoint; int startIndex; cout<<"请输入单源点:&q

数据结构之---C语言实现最短路径之Dijkstra(迪杰斯特拉)算法

此处共有两段代码: 一. 这段代码比较全面,其中参考了github上的相关源码.可以说功能强大. //Dijkstra(迪杰斯特拉算法) #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 100 // 矩阵最大容量 #define INF 65535 // 最大值65535 #define isLetter(a) ((((a)>='a')&&((a)<

看数据结构写代码(47)迪杰斯特拉最短路径算法

这个算法的 思想 根 求 最小生成树算法 普里姆(Prim)算法 极其相似.迪杰斯算法 是求 一个顶点 到其他 顶点的 最短路径算法. 下面 上代码:(用的是 邻接矩阵 表示法) //迪杰斯特拉 最短路径. //从 vex顶点 到其他 顶点的 最短路径 void shortestPath_Dij(MGraph g,char vex){ int loc = graphLocation(g,vex); int minArray[MAX_VERTEX_NUM]={0};//最小路径值 bool fin

算法学习 - Dijkstra(迪杰斯特拉)算法学习

Dijkstra算法 其实Dijkstra是单源点最短路径的基础算法,这个算法的目的就是找到一个图中的某个点V到这个图中其他点的最短路径. 条件 有向图 没有负权值路径 时间复杂度:O(E) + O(V^2) = O(V^2) 当图是稠密的时候和稀疏的时候时间复杂度还是有点差别的. 代码实现 其实这个还挺简单的,单源点最短路径还有一个Bellman-Ford算法,以后在写,比较简单. Dijkstra算法: // // main.cpp // Dijkstra // // Created by