精华内容
下载资源
问答
  • Dijkstra 有向图

    2018-06-15 15:29:26
    Dijkstra 有向图#include<stdio.h> #include<stdlib.h> #include<string.h> #include<math.h> #include<algorithm> #include<queue&...

    Dijkstra 有向图

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<math.h>
    #include<algorithm>
    #include<queue>
    #include<stack>
    #include<deque>
    #include<iostream>
    using namespace std;
    const int INF=0x3f3f3f3f;
    const int N=200;
    
    int graph[N][N];
    int check[N];
    int dis[N];
    int n;
    
    void Dijkstra(int u0)
    {
        int i,p,j;
        int inf,mid;
        for(i=1; i<=n; i++)
            dis[i]=graph[u0][i];
        check[u0]=-1;
        for(i=0; i<n-1; i++)
        {
            inf=INF;
            mid=u0;
            for(j=1; j<=n; j++)
            {
                if(check[j]!=-1&&dis[j]<inf)
                {
                    inf=dis[j];
                    mid=j;
                }
            }
            if(inf!=INF)
            {
                check[mid]=-1;
                for(j=1; j<=n; j++)
                {
                    if(check[j]!=-1&&dis[j]>graph[mid][j]+dis[mid])
                        dis[j]=graph[mid][j]+dis[mid];
                }
            }
        }
    }
    
    int main()
    {
        int m,a,b,c;
        int i,p,j;
        while(scanf("%d%d",&n,&m)!=EOF)
        {
            if(n==0&&m==0)
                break;
            memset(check,0,sizeof(check));
            memset(dis,0,sizeof(dis));
            for(i=1; i<=n; i++)
                for(j=1; j<=n; j++)
                {
                    if(i==j)
                        graph[i][j]=0;
                    else
                        graph[i][j]=INF;
                }
    
            for(i=1; i<=m; i++)
            {
                scanf("%d%d%d",&a,&b,&c);
                graph[a][b]=graph[b][a]=c;
            }
            Dijkstra(1);
    
            printf("%d\n",dis[n]);
        }
        return 0;
    }
    

    展开全文
  • 使用c++实现的Dijkstra算法,主要是为了在有向图中寻找到起始点到终点;再返回起始点的最短路径;
  • dijkstra算法有向图demo,无BUG版,无BUG版,无BUG版,python版
  • 要求:n个顶点m条路组成的有向图,输出每个点到达第x个点再从第x个点返回出发点走的距离的最短距离中的最大值。 方法:dijkstra变形 1.从第x个点返回出发点的最短距离可以直接用dijkstra求出。 2.从出发点到第x个...

    要求:n个顶点m条路组成的有向图,输出每个点到达第x个点再从第x个点返回出发点走的距离的最短距离中的最大值。

    方法:dijkstra变形

    1.从第x个点返回出发点的最短距离可以直接用dijkstra求出。

    2.从出发点到第x个点的最短距离乍一看是n个最短路,简单推理一下:第i个点到第x个点的最短距离等于反向的第x个点到第i个点的最短距离,因此构建一个和第1步反向的图,用dijkstra求第x个点到所有点的最短路即可。正所谓反(边)反(所求方向)得正。

    #include<iostream>
    #include<stdio.h>
    #include<queue>
    #include<map>
    #include<string.h>
    #include<math.h>
    #include<algorithm>
    #define inf 0x3f3f3f3f
    using namespace std ;
    int n , m , x ;
    int map1[1005][1005] ;
    int map2[1005][1005] ;
    int vis[1005] ;
    int dis1[1005] ;
    int dis2[1005] ;
    void dijkstra()
    {
    	int i , j , k ;
    	int min1 , temp ;
    	int ans = 0 ;
    	memset(vis , 0 , sizeof(vis)) ;
    	for(i = 1 ; i <= n ; i ++)
    		dis1[i] = map1[x][i] ;
    	dis1[x] = 0 ;
    	vis[x] = 1 ;
    	for(i = 1 ; i < n ; i ++)
    	{
    		min1 = inf ;
    		for(j = 1 ; j <= n ; j ++)
    			if(!vis[j] && dis1[j] < min1)
    			{
    				min1 = dis1[j] ;
    				temp = j ;
    			}
    		vis[temp] = 1 ;
    		for(j = 1 ; j <= n ; j ++)
    		    dis1[j] = min(dis1[j] , dis1[temp] + map1[temp][j]) ;
    	}
    	
    	memset(vis , 0 , sizeof(vis)) ;
    	for(i = 1 ; i <= n ; i ++)
    		dis2[i] = map2[x][i] ;
    	dis2[x] = 0 ;
    	vis[x] = 1 ;
    	for(i = 1 ; i < n ; i ++)
    	{
    		min1 = inf ;
    		for(j = 1 ; j <= n ; j ++)
    			if(!vis[j] && dis2[j] < min1)
    			{
    				min1 = dis2[j] ;
    				temp = j ;
    			}
    		vis[temp] = 1 ;
    		for(j = 1 ; j <= n ; j ++)
    		    dis2[j] = min(dis2[j] , dis2[temp] + map2[temp][j]) ;
    	}
    	
    	for(i = 1 ; i <= n ; i ++)
    	    ans = max(ans , dis1[i] + dis2[i]) ;
    	printf("%d\n" , ans) ;
    }
    int main()
    {
    	int i , j , k , p ;
    	int a , b , c ; 
    	scanf("%d%d%d" , &n , &m , &x) ;
    	memset(map1 , inf , sizeof(map1)) ;
    	memset(map2 , inf , sizeof(map2)) ;
        memset(dis1 , inf , sizeof(dis1)) ;
        memset(dis2 , inf , sizeof(dis2)) ;
        for(i = 0 ; i < m ; i ++)
        {
        	scanf("%d%d%d" , &a , &b , &c) ;
        	map1[a][b] = c ;
        	map2[b][a] = c ;
    	}
    	dijkstra() ;
    }
    

     

    展开全文
  • (2)基本要求 采用Dijkstra算法求解中两个顶点的最短路径,由于给定的是稀疏,所以要采用邻接表作为的存储结构。 要求采用C++实现的构造和求解最短路径的过程。 要求自己编写程序进行实现,不允许使用...
  • 有向图Dijkstra算法实现,C++语言实现
  • Dijkstra算法实现有向图单源最短路径

    千次阅读 2016-10-24 11:53:15
    给定一个带权有向图G=(V,E),其中每条边的权都是非负实数。另外,还给定V中的一个顶点,称为源,现在要求解的是从源到其他所有顶点的最短路长度,即所经过路径的权的和,这就是所谓的单源最短路径问题。   #...

           给定一个带权有向图G=(V,E),其中每条边的权都是非负实数。另外,还给定V中的一个顶点,称为源,现在要求解的是从源到其他所有顶点的最短路长度,即所经过路径的权的和,这就是所谓的单源最短路径问题。

            如图所示,是一个有向图,从1点出发,,要求得出从源到其他所有顶点的最短路长度。

                                                        


          Dijkstra算法是解单源最短路径问题的一个贪心算法,其思想是:设置顶点集合S并不断做贪心选择来扩充这个集合,初始时,S中仅包含源,设u为G的某一顶点,并用数组dist记录当前每个顶点所对应的最短路径长度,Dijkstra算法每次从V-S中取出具有最短路径长度的顶点u,将u添加到S中,同时对数组dist做必要的修正。一旦S包含了所有V中的顶点,dist就记录了从源到所有其他顶点之间的最短路径长度。

    #include <stdio.h>
    int main()
    {
        int e[10][10],dis[10],book[10],i,j,n,m,t1,t2,t3,u,v,min;
        int inf=99999999; //用inf(infinity的缩写)存储一个我们认为的正无穷值
        //读入n和m,n表示顶点个数,m表示边的条数
        scanf("%d %d",&n,&m);
                                                                       
        //初始化
        for(i=1;i<=n;i++)
            for(j=1;j<=n;j++)
                if(i==j) e[i][j]=0;
                  else e[i][j]=inf;
                                                                                 
        //读入边
        for(i=1;i<=m;i++)
        {
            scanf("%d %d %d",&t1,&t2,&t3);
            e[t1][t2]=t3;
        }
        //初始化dis数组,这里是1号顶点到其余各个顶点的初始路程
        for(i=1;i<=n;i++)
            dis[i]=e[1][i];
        //book数组初始化
        for(i=1;i<=n;i++)
            book[i]=0;
        book[1]=1;
                                                                       
        //Dijkstra算法核心语句
        for(i=1;i<=n-1;i++)
        {
            //找到离1号顶点最近的顶点
            min=inf;
            for(j=1;j<=n;j++)
            {
                if(book[j]==0 && dis[j]<min)
                {
                    min=dis[j];
                    u=j;
                }
            }
            book[u]=1;
            for(v=1;v<=n;v++)
            {
                if(e[u][v]<inf)
                {
                    if(dis[v]>dis[u]+e[u][v])
                        dis[v]=dis[u]+e[u][v];
                }
            }
        }
                                                                       
        //输出最终的结果
        for(i=1;i<=n;i++)
            printf("%d ",dis[i]);
                                                                           
        getchar();
        getchar();
        return 0;
    }
    

    展开全文
  • 观察程序发现这个程序仅仅适用于无向图,程序的第八行a=a+a',会在有向图时产生错误,删除后仍然不能很好的适应有向图; 所以自己动手写了一个,考虑到写的不多,如果有错误,希望留言纠正。 1.案例...

    在网上搜索了关于Dijkstra算法的matlab程序,发现流传较多的是:

    https://blog.csdn.net/u013414501/article/details/50506907

    观察程序发现这个程序仅仅适用于无向图,程序的第八行a=a+a',会在有向图时产生错误,删除后仍然不能很好的适应有向图;

    所以自己动手写了一个,考虑到写的不多,如果有错误,希望留言纠正。

     

    1.案例

    本文的代码通过这个有向图来运行。例子来源:https://www.jianshu.com/p/2121406db974

    2.代码

    clc;clear all;
    %输入距离矩阵(有向)
    n=8;%顶点的个数
    m=inf;
    a=[0 1 2 9 m m m m
       m 0 m 2 m m m m
       m m 0 8 m 5 m m
       m m m 0 7 m 9 m
       m m m 5 0 4 m 3
       m m m m 4 m m m
       m m m m m m m m
       m m m m m m m m];
    %创建新矩阵b
    b=zeros(n,n+1);%n+1列代表过程
    b(1,1:n)=a(1,:);%复制第一行
    b(1,n+1)=1;
    index=zeros(1,n);%索引
    index(1)=1;
    for i=2:n
        r=find(index == 0);%确定还未迭代过的顶点
        s=find(b(i-1,r)==min(b(i-1,r)));%在没有选择过的顶点中选取最小的值的位置
        %会有同时多个相同值得情况,所以采用随机数选取其中一个
        if length(s)>1
            s=randint(1,1,s);
        end
        s=r(s);%为s赋值为未迭代过的最小值顶点
        for j=1:n
            b(i,j)=min(b(i-1,j),b(i-1,s)+a(s,j));
        end;
        index(s)=1;
        b(i,n+1)=s;
    end;
    b

    由于是初学者,语言功底较弱,特别解释一下,s代表当次循环中选取的顶点,如i=2时,s=2,即为B顶点。

    3.结果

    b =
    
         0     1     2     9   Inf   Inf   Inf   Inf     1
         0     1     2     3   Inf   Inf   Inf   Inf     2
         0     1     2     3   Inf     7   Inf   Inf     3
         0     1     2     3    10     7    12   Inf     4
         0     1     2     3    10     7    12   Inf     6
         0     1     2     3    10     7    12    13     5
         0     1     2     3    10     7    12    13     7
         0     1     2     3    10     7    12    13     8

    如有错误,欢迎勘误。

    展开全文
  • VS2008环境下C++实现Dijkstra算法,查找有向图最短路径
  • 给定一带权中每条边的权值是非负的,代表着两顶点之间的距离。指定中的一顶点为源点,找出源点到其它顶点的最短路径和其长度的问题,即是单源最短路径问题。 什么是Dijkstra算法? 求解单源最短路径问题的...
  • 有向图Dijkstra算法

    千次阅读 2017-04-01 17:35:48
    算法原理就不多说了,就讲一讲实现 代码采用邻接矩阵的数据结构,a(i,j)代表第i个节点到第j个节点的距离,不能到达为无穷,代码中设为10000000。 另外数组len代表节点0到每个节点到最短路程,每循环一次就更新一次...
  • 有向图最短路径问题---Dijkstra算法(过程)
  • C++ 有向图最短路径之Dijkstra算法

    千次阅读 2019-03-26 22:01:42
    一、思路 1.Dijkstra算法 每次都是从起始顶点v出发,找与v有关的有向边<v,u>。找到<v, u>之后,找有向边<...,如果通过绕过顶点u而使从v到k的路径更...如上面的有向图:起始顶点为0 (1)先将顶点...
  • 实现有向图Dijkstra最短路径算法

    千次阅读 2019-05-19 22:38:31
    实现有向图Dijkstra最短路径算法,输入起始顶点Vi和终止顶点Vj,输出从Vi到Vj的最短路径及其长度。 在此基础上,借助OpenCV将图及其上从Vi到Vj的最短路径画出来。函数Dijkstra() -> 源文件Dijkstra.cpp 效果图...
  • 说明:对于dijkstra而言,是否有向判断方法几乎一致 思想:在迭代过程中,假设求出了i->j的最短路径,这是我们擦除这条边a,然后再次求i->j的最短路径b,此时如果b路径存在,那么a+b就是最小环的长度 Floyd求...
  • 我用Dijkstra算法,写了一个无环有向图/无向图(多加一条相反的路径仅此而已) 的最短路径问题的解决方案。如果是无向图也很简单,把每个无向的edge拆开成两个有向的就可以解决了。为了每次弹出正确的端点,我也实现...
  • 设计并实现有向图的邻接表表示 实现Dijkstra算法。 输出Dijkstra中从目标起点到各顶点的最短路径 程序代码 #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;algorithm&...
  • 有向图Dijkstra算法实现模板

    千次阅读 2015-07-28 12:52:51
    有向图Dijkstra算法实现#include using namespace std;const int maxnum = 100; const int maxint = 999999;// 各数组都从下标1开始 int dist[maxnum]; // 表示当前点到源点的最短路径长度 int prev[maxnum]; // ...
  • 单源最短路径问题求解带权有向图(邻接表表示法)完整源码#include #include #include #include using namespace std;map, vector, int, double>>> EWD;int main() { int V, E; cin >>
  • Dijkstra(邻接矩阵有向图)C 实现~

    千次阅读 2017-08-09 10:24:56
    这是邻接矩阵的Dijkstra 与 邻接表比较类似.
  • 算法思路稍后附上源代码%% Dijkstra function minWeightMatrix=shortestPath(G,nodeNum) minWeightMatrix=zeros(nodeNum,nodeNum); for i=1:nodeNum %获取每个顶点到其它节点最短路径权值,Dijkstra 源点遍历 D=G...
  • 昨天的数据库考试,题目本身都简单的,但是感觉时间有点紧张,可能和自己有点墨迹有关。题目不怕不会做,就怕读错题,上了大学养成了考试“做完一遍... 用该算法的思想还可以求无向图中的“最小”环。 例如poj1743...
  • 的应用中,一个很重要的需求:我们需要知道从某一个点开始,到其他所有点的最短路径。 这其中,Dijkstra算法是典型的最短路径算法。它的关键思想是以起始点为中心,外一层层扩散,直到扩展到终点为止。...
  • Dijkstra 算法用于解决 边权重非负、加权有向图、单起点最短路径 问题。 Dijkstra 算法与在加权无向图中查找最小生成树的方法类似:每一步添加一个非树顶点到树中,直到所有顶点都在树中。
  • 最短路径算法是图论中的常见问题,... 无权是有权最短路径的特例,即边的权重均是1。算法类似于BFS(宽度优先搜索),在实现时需要一个宽度优先搜索的队列。全局变量Distance用来保存所有点到输入顶点的距离。以邻接
  • 读者盆友,下午好啊!终于来到图中最复杂的部分了:加权又向...文章目录一、加权有向边的数据类型二、加权有向图的数据类型三、最短路径的Dijkstra算法四、源码 一、加权有向边的数据类型 package com.cmh.algorith...
  • 本代码 利用 Dijkstra's Shortest Path Algorithm 求解有向图的最短路径。 包括 图的构建,求解过程的,排序使用的最小堆 等所有的源代码,并包括测试用例。 是学习最小堆 和 Dijkstra's Shortest Path Algorithm ...
  • #include <iostream> using namespace std;...//Dijkstra算法计算点v到上各个点的最短距离 void Dijkstra(int graph[][N], int v, int n) {//v为起点,//n为点个个数 for (int i = 1; i <

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,744
精华内容 10,697
关键字:

dijkstra有向图