算法复习:最短路Dijkstra - Ford - Floyd

Dijkstra算法适用范围是单源最短路,有向图或者无向图,不能处理负权值

Floyd算法适用多源最短路,有向图或者无向图,可以处理负权值但是不能处理负权回路

Ford 算法多源最短路,可以处理负权值,能检测负权回路

Leetcode 743. 网络延迟时间

先用Dijkstra算法解,输入是vector要转存一下,另外找的是最后一个传播到的节点所用时间

#define max 999999
#define CLR(donser,value) memset(donser,value,sizeof(donser))
class Solution {
public:
    int networkDelayTime(vector<vector<int>>& times, int N, int K)
    {
        int dis[N+1],map[N+1][N+1];
        CLR(dis,max);
        bool visit[N+1];
        CLR (visit,false);
        for(int i=1;i<=N;i++)//先初始化map
            for(int j=1;j<=N;j++)
                map[i][j]=max;
        for(int i=0;i<times.size();i++)//把边转存到map
            map[times[i][0]][times[i][1]]=times[i][2];
        for(int i=1;i<=N;i++)//和起点直接相连的边
        {
            if(i==K)
                dis[i]=0;
            else
                dis[i]=map[K][i];
        }
        visit[K]=true;//起点做标记
        for(int i=1;i<=N;i++)//循环N次
        {
            int min=max,k;
            for(int j=1;j<=N;j++)//找未加入visit的点所连最小边
            {
                if(!visit[j]&&min>dis[j])
                    min=dis[k=j];//k记录取到最小值时的下标
            }
            if(min==max)//不存在没加入的边了
                break;
            visit[k]=true;
            for(int j=1;j<=N;j++)//给没有加入的边更新权值
            {
                if(!visit[j]&&dis[j]>dis[k]+map[k][j])//新加入了K,把与K相连的边加入
                    dis[j]=dis[k]+map[k][j];
            }
        }
        int find=0;
        for(int i=1;i<=N;i++)
            if(dis[i]>find)
                find=dis[i];
        if(find==max)
            return -1;
        else
            return find;
    }
};

leedcode 743

另外,Dijkstra算法模板:

#define N 101
#define max 999999
#define CLR(arr,what) memset(arr,what,sizeof(arr))
int nodenum,edgenum;
int map[N][N],dis[N];
bool visit[N];
int Dijkstra(int src,int des)//输入开始点和结束点
{
    int temp,k;
    CLR(visit,false);
    for(int i=0;i<=nodenum;i++)//先把和开始点直接相连的边找出来
    {
        if(i==src)
            dis[i]=0;//dis[i]存连入i的边,起始点赋0
        else
            dis[i]=map[src][i];
    }
    visit[src]=true;//起始点做标记
    dis[src]=0;
    for(int i=1;i<=nodenum;i++)//做i次循环
    {
        temp=max;
        for(int j=1;j<=nodenum;j++)//寻找没有加入visit的节点中权值最小的
        {
            if(!visit[j]&&temp>dis[j])
                temp=dis[k=j];
        }
        if(temp==max)//不存在没有加入的边时结束
            break;
        visit[k]=true;//访问标记
        for(int j=1;j<=nodenum;j++)//加入k点以后更新和k相连的边
        {
            if(!visit[j]&&dis[j]>dis[k]+map[k][j])
                dis[j]=dis[k]+map[k][j];
        }
    }
    return dis[des];
}

原文地址:https://www.cnblogs.com/dzzy/p/12348705.html

时间: 2024-10-05 10:50:58

算法复习:最短路Dijkstra - Ford - Floyd的相关文章

HDU 2544 最短路 Dijkstra、Floyd、Bellman-Ford、SPFA算法

原题地址:http://acm.hdu.edu.cn/showproblem.php?pid=2544 最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 43669    Accepted Submission(s): 19216 Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-s

hdu 2544 最短路(Dijkstra Or Floyd Or dfs)

Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗? Input 输入包括多组数据.每组数据第一行是两个整数N.M(N<=100,M<=10000),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路.N=M=0表示输入结束.接下来M行,每行包

最短路知识点总结(Dijkstra,Floyd,SPFA,Bellman-Ford)

Dijkstra算法: 解决的问题: 带权重的有向图上单源最短路径问题.且权重都为非负值.如果采用的实现方法合适,Dijkstra运行时间要低于Bellman-Ford算法. 思路: 如果存在一条从i到j的最短路径(Vi.....Vk,Vj),Vk是Vj前面的一顶点.那么(Vi...Vk)也必定是从i到k的最短路径.为了求出最短路径,Dijkstra就提出了以最短路径长度递增,逐次生成最短路径的算法.譬如对于源顶点V0,首先选择其直接相邻的顶点中长度最短的顶点Vi,那么当前已知可得从V0到达Vj

【啊哈!算法】算法6:只有五行的Floyd最短路算法

暑假,小哼准备去一些城市旅游.有些城市之间有公路,有些城市之间则没有,如下图.为了节省经费以及方便计划旅程,小哼希望在出发之前知道任意两个城市之前的最短路程. 上图中有4个城市8条公路,公路上的数字表示这条公路的长短.请注意这些公路是单向的.我们现在需要求任意两个城市之间的最短路程,也就是求任意两个点之间的最短路径.这个问题这也被称为“多源最短路径”问题. 现在需要一个数据结构来存储图的信息,我们仍然可以用一个4*4的矩阵(二维数组e)来存储.比如1号城市到2号城市的路程为2,则设e[1][2]

最短路 spfa, dijkstra, Floyd

spfa 1 #include <stdio.h> 2 #include <queue> 3 using namespace std; 4 5 #define RANGE 101 6 #define MAX 0x3f3f3f3f 7 int cost[RANGE][RANGE]; 8 int d[RANGE]; 9 bool used[RANGE]; 10 int n,m; 11 12 void spfa( int s ) 13 { 14 int i,now; 15 // 初始化

(最短路径算法整理)dijkstra、floyd、bellman-ford、spfa算法模板的整理与介绍

这一篇博客以一些OJ上的题目为载体.整理一下最短路径算法.会陆续的更新... 一.多源最短路算法--floyd算法 floyd算法主要用于求随意两点间的最短路径.也成最短最短路径问题. 核心代码: /** *floyd算法 */ void floyd() { int i, j, k; for (k = 1; k <= n; ++k) {//遍历全部的中间点 for (i = 1; i <= n; ++i) {//遍历全部的起点 for (j = 1; j <= n; ++j) {//遍历

hdu 2544 最短路 (dijkstra,floyd)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=2544 题目大意:找到两点间最短的距离值. 代码一:(dijkstra算法) 1 #include <iostream> 2 #include <cstdio> 3 using namespace std; 4 int n,Min,node[105],visit[105],map[105][105]; 5 void set() 6 { 7 for (int i=1; i<=n; i

最短路(Dijkstra,Floyd,Bellman_Ford,SPFA)

当然,这篇文章是借鉴大佬的... 最短路算法大约来说就是有4种——Dijkstra,Floyd,Bellman_Ford,SPFA 接下来,就可以一一看一下... 1.Dijkstra(权值非负,适用于有向图及无向图,单源最短路) 1 Dijkstra's算法解决的是图中单个源点到其它顶点的最短路径.只能解决权值非负(看了代码就知道了)2 Dijkstral只能求出任意点到达源点的最短距离(不能求出任意两点之间的最短距离),同时适用于有向图和无向图,复杂度为O(n^2).3算法的过程: 1设置顶

最短路 Dijkstra算法

Dijksitra算法求最短路仅仅适用于不存在右边是负权的情况(Bellman-Ford算法没有这一个限制).主要特点是从起点为中心向外层层扩展,直到扩展到终点为止. 最短路的最优子结构性质 即一个最短路路径中经过的所有点这条路均是其最短路.(反证法易证) Dijkstra基本思路: ①找到最短距离已经确定的顶点,从它出发更新相邻顶点的最短距离 ②此后不需要再关心1中的"最短距离已经确定的顶点" 在最开始的时候,只有起点的最短距离是确定的.而在尚未使用过的顶点中,距离d[i]最小的顶点