算法笔记——最短路径问题：Dijkstra算法/BF和SPFA/Floyd

最新推荐文章于 2022-05-14 15:18:51 发布
最新推荐文章于 2022-05-14 15:18:51 发布
阅读量414 收藏 1
点赞数
分类专栏： PAT 算法 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WF19980719/article/details/106485995
版权
算法 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
PAT
11 篇文章 0 订阅
订阅专栏 

 1. Dijkstra算法:解决单源最短路径无负边

//=============算法思路====================
//1:邻接矩阵：一般不超过1000，无向边和有向边的区别
//2：邻接表（用链表），无向边和有向边的区别
//2.1：为了简便，vector(变长数组）
//3:Dijkstra算法
//3.1:Di伪代码
//G为图，一般设为全局变量；数据d为源点到各点的最短路径长度，s为起点
//D(G,D[],S)
//{
//初始化
//for(循环n次)
//{
//    u为D[u]中最小的还未被访问的顶点的标号；
//    设u已访问
//        for（以u为出发能到达的所有顶点V）
//    {
//        if(v未被访问&&以u为中介点使s到顶点v的最短路径更优）
//           优化d[v];
//             pre[v]=u;//记录v的前驱顶点是u//老是思考的一个问题：边界情况呢？
//4：怎么记录最短路径？上面可以进行优化的隐含信息：使d[v]变小的情况为让u作为s到v最短路径的前一个节点。
//4.1:记录v的前驱节点，pre[],第一个节点是没有前驱节点，初始化为自己
//4.2:然后递归找最短路径
//5:有多条最短路径：找第二标尺
//5.1：每一条边再加一个边权，最短路径的情况下求最小花费
//5.1.1:要判断最短路径相等的情况下，进行最小花费的判断
//5.2:每一个点增加一个点权（例如每个城市收集的物资），在前面的情况下求点权最大
//5.1.1:要判断最短路径相等的情况下，进行最大权值的判断
//5.3：有多少条最短路径
//5.3.1：更新的情况下：用num[u]代替num[v],表示最短路径（s->v)与(s->u)相同
//5.3.2：相等的情况：那么为num[v]+num[u],表示到达该点有多条路径
//}
//=============算法改进====================
//Dj+DFS
//1:先用DJ记录下最短路径;
//1.1:有可能有多个前驱节点：所以设置为vector<int>pre[MAXV]
//2:遍历最短路径（递归树），找到第二标尺最优的路径
//2.1：怎么写DFS函数：
//2.1.1:作为全局变量的第二标尺optValue
//2.1.2:记录最有路径（使用vector存储）
//2.1.3:临时记录DFS遍历叶子节点时的路径tempPath(使用vector存储）
//2.2:思路：
//2.2.1:递归边界（到达起点，也就是递归树的叶子节点）
//2.2.2:此时tempPath中存放了路径，再把起点加入，进行第二标尺的计算，与optValue进行比较
//2.3:递归式，遍历pre[v]的所有节点进行递归
//2.4:怎么生成tempPath
//2.4.1:访问当前节点v时把v加入
//2.4.2:遍历pre[v]进行递归
//2.4.3:所有节点全部遍历完之后删除v
//=============算法改进====================
//=============算法思路====================
#include <iostream>
#include <algorithm>
#include<vector>
#include<cstdio>
using namespace std;
//定义MAXV为最大顶点数，INF为一个很大的数
const int MAXV = 1000;
const int INF = 1000000000;//设为很大的数
//邻接矩阵版
int n,m,s, G[MAXV][MAXV];//n为顶点数,m为边数，s为起点，MAXV为最大顶点数
int d[MAXV],pre[MAXV];//起点到各点的距离
bool visit[MAXV] = { false };//点是否被访问
//DijkstraDFS新增的变量声明
//1:pre不进行初始化，那么起点的前驱节点设置为自己？
vector<int>pre[MAXV];//存放节点的前驱节点
int optValue;//第二标尺的最优值
vector<int>tempPath, path;//存放最佳路径和临时路径
void DijkstraDFS(int s) {
    //初始化
    fill(d, d + MAXV, INF);//需要加上头文件#include <algorithm>using namespace std;
    d[s] = 0;//自己到自己的距离为0
    /*visit[s] = true;这点在后面的循环中会进行执行*/
    for (int i = 0; i < n; i++)
    {
        int u = -1, min = INF;//u用记录最小值的下标，min用来记录最下值
        //利用一个for循环查找出当前最小的下标
        for (int j = 0; j < n; j++)
        {
            if (visit[j] == false && d[j] < min)
            {
                u = j;
                min = d[j];
            }
        }
        //防止出现不连通图，进行判断
        if (u == -1) { return; }
        /* else 有点多余，如果前面条件满足，就return了*/
        visit[u] = true;
        //以u出发到达的其他顶点v是否可以进行更新
        for (int v = 0; v < n; v++)
        {
            //还加了一个条件：if(G[u][v]!=INF//说明有边
            if (visit[v] == false && G[u][v] != INF  )
            {
                .if (d[u] + G[u][v] < d[v])
                {
                    d[v] = d[u] + G[u][v];
                    //进行清空
                    pre[v].clear();
                    pre[v].push_back(u);//把u加入前驱节点
                }
                else if (d[u] + G[u][v] = d[v])
                {
                    pre[v].push_back(u);
                }
                
               
            }
        }
    }
}
void DFS(int v)
{
    if (v == s) {
        tempPath.push_back(v);
        int value=0;//用来记录tempPath中的值，判断是否要对optValue进行更新
        //计算value值
        //边权之和；点权之和

        if (value优于optValue) {
            optValue = value; path = tempPath;
        }
        tempPath.pop_back(v);
        //要进行返回，递归边界
        return;
    }
    tempPath.push_back(v);
    for (int i = 0; i < pre[v].size(); i++)
    {
        DFS(pre[v][i]);
    }
    tempPath.pop_back(v);
}
void Dijkstra(int s)//s为起点
{
    //初始化
    fill(d, d + MAXV, INF);//需要加上头文件#include <algorithm>using namespace std;
    d[s] = 0;//自己到自己的距离为0
    /*visit[s] = true;这点在后面的循环中会进行执行*/
    for (int i = 0; i < n; i++)
    {
        int u = -1, min = INF;//u用记录最小值的下标，min用来记录最下值
        //利用一个for循环查找出当前最小的下标
        for (int j = 0; j < n; j++)
        {
            if (visit[j] == false && d[j] < min)
            {
                u = j;
                min = d[j];
            }
        }
        //防止出现不连通图，进行判断
        if (u == -1) { return; }
        /* else 有点多余，如果前面条件满足，就return了*/
        visit[u] = true;
        //以u出发到达的其他顶点v是否可以进行更新
        for (int v = 0; v < n; v++)
        {
            //还加了一个条件：if(G[u][v]!=INF//说明有边
            if (visit[v] == false &&G[u][v]!=INF &&d[u] + G[u][v] < d[v])
            {
                d[v] = d[u] + G[u][v];
                pre[v] = u;//记录v的前驱节点是u
            }
        }
    }
    
}
void DFS(int s, int v)//输出起点到终点的最短路径
{
    //递归边界
    if (s == v) { printf("%d\n", s); return; }
    DFS(s, pre[v]);//往前递归
    //回来时的处理
    printf("%d\n", v);//每一层回来输出每一层的顶点号
}
//邻接表法
//结构构造函数初始化：与c++和java中构造函数类似
struct node {
    int v;//变得终点号
    int w;//边权
    //定义无参构造函数
    node(){}
    //构造函数简化成一行
    node(int _v, int _w) :v(_v), w(_w) {}
};
//算法初始化和找u的过程是一样的，只是查找以u的中介的其他顶点更新不一样
vector<node>adj[MAXV];//图G,adj[u]存放从顶点u出发可以到达的所有顶点
void Dijkstra1(int s)//s为起点
{
    //初始化
    fill(d, d + MAXV, INF);//需要加上头文件#include <algorithm>using namespace std;
    d[s] = 0;//自己到自己的距离为0
    /*visit[s] = true;这点在后面的循环中会进行执行*/
    for (int i = 0; i < n; i++)
    {
        int u = -1, min = INF;//u用记录最小值的下标，min用来记录最下值
        //利用一个for循环查找出当前最小的下标
        for (int j = 0; j < n; j++)
        {
            if (visit[j] == false && d[j] < min)
            {
                u = j;
                min = d[j];
            }
        }
        //防止出现不连通图，进行判断
        if (u == -1) { return; }
        /* else 有点多余，如果前面条件满足，就return了*/
        visit[u] = true;
        //以u出发到达的其他顶点v是否可以进行更新
        //adj[u].size()获取u所连的边的个数
        for (int j = 0; j < adj[u].size(); j++)
        {
            //通过邻接表直接获得u能到达的顶点v
            int v = adj[u][j].v;//adj中储存了各条边的情况
            //还加了一个条件：if(G[u][v]!=INF//说明有边
            if (visit[v] == false && d[u]+ adj[u][j].w< d[v])
            {
                d[v] = d[u] + adj[u][j].w;
            }
        }
    }

}
//对应DJ+DFS:1.1:找最短路径，有可能有多个前驱节点：所以设置为vector<int>pre[MAXV]
void Dj(int v)
{
	fill(d, d + MAXV, INF);
	d[v] = 0;
	for (int i = 0; i < n; i++)
	{
		int u = -1, min = INF;
		for (int j = 0; j < n; j++)
		{
			if (vis[j] == false && d[j] < min)
			{
				u = j;
				min = d[j];
			}
		}
		if (u == -1)return;
		vis[u] = true;
		for (int k = 0; k < n; k++)
		{
			if (vis[k] == false && d[u] + G[u][k] < d[k])
			{
				//d[u]要进行更新
				d[k] = d[u] + G[u][k];
				pre[k].clear();
				pre[k].push_back(u);
			}
			else if (vis[k] == false && d[u] + G[u][k] == d[k])\
			{
				pre[k].push_back(u);

			}
		}
	}
}
int main()
{
    int u, v, w;
    scanf("%d%d%d", &n, &m, &s);//顶点个数、边数、起点编号
    fill(G[0], G[0] + MAXV * MAXV, INF);//初始化图
    for (int i = 0; i < m; i++)
    {
        scanf("%d%d%d", &u, &v, &w);//输入u、v以及u->v的边权
        G[u][v] = w;
    }
    Dijkstra(s);
    for (int i = 0; i < n; i++)
    {
        printf("%d ", d[i]);//输出所有顶点的最短距离
    }
    //for (int i = 0; i < n; i++)
    //{
    //    printf("%d", pre[i]);//输出所有顶点的最短距离
    //}

    return 0;
}
  1. BF：可以解决负边问题

2.1:[PAT1003]

//BF算法：解决单源路径最短问题（可处理负边权的问题）
//思路：
//1.1对图中的边进行V-1次遍历(用最小生成树理解松弛操作不会超过V-1:最小生成树最多不会超过V个，并且起点已经为d[s]=0,不能再进行优化)，对每一个边，看是否可以进行优化
//1.2最后再检查一下是否有负环
//2：解决实际问题：有多条路径最短的问题：记录num值的时候，为了防止重复的值发生，则需要重新记录（并且用set进行存储）
//出现的问题：
#include <iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
const int maxv = 500;
const int INF = 1000000000;
int n, m;//定义点和边
struct node{
    int v;//边的终点编号
    int w;//边权
    node(int v_, int w_) :v(v_), w(w_) {};
};
vector<node>adj[maxv];//图G的邻接表
int weight[maxv],num[maxv],w1[maxv];//用来存放个点的权值和数量,w1是用来存放最大的点权
set<int>pre[maxv];//记录前驱的数组
int d[maxv];

void kus(int s) {
    //初始化
    fill(num, num + maxv, 0);
    fill(d, d + maxv, INF);
    d[0] = 0;
    num[s] = 1;
    w1[s] = weight[s];//这一步忘记加入
    for (int i = 0; i < n - 1; i++)//遍历n-1次
    {
        //每次遍历每一条边
        for(int u=0;u<n;u++)
            for (int j = 0; j < adj[u].size(); j++)//看是否可以以u为中介可以进行优化
            {
                int v = adj[u][j].v;//邻接边的顶点
                int dis = adj[u][j].w;//邻接边的边权
                if (d[u] + dis < d[v])//可以进行优化:是对顶点进行优化
                {
                    d[v] = d[u] + adj[u][j].w;//覆盖d
                    w1[v] = w1[u] + weight[v];//优化边的权值
                    num[v] = num[u];//直接覆盖
                    pre[v].clear();
                    pre[v].insert(u);
                }
                else if (d[u] + dis == d[v])//找到路径相等
                {
                    if(w1[u] + weight[v]>w1[v])w1[v] = w1[u] + weight[v];//优化边的权值
                    pre[v].insert(u);//一步步进行优化
                    
                                                                         
              //此时有可能会有重复的节点，所以需要重新计算
                    num[v] = 0;
                set<int>::iterator it;
                for (it = pre[v].begin(); it != pre[v].end(); it++)
                {
                    num[v] += num[*it];
                }
                }
            }
    }

}
int main()
{
    int s, e;
    scanf_s("%d%d%d%d", &n, &m, &s, &e);
    for (int i = 0; i < n; i++)scanf_s("%d", &weight[i]);
    int s1, s2, s3;
    for (int i = 0; i < m; i++)
    {
        scanf_s("%d%d%d", &s1, &s2, &s3);
        adj[s1].push_back(node(s2,s3));
        adj[s2].push_back(node(s1, s3));
    }
    kus(s);//传入起点进去
    printf("%d %d", num[e], w1[e]);
    return 0;
}
  1. SPFA
    3.1:[PAT1003]

//思路： SPFA(shortest path faster algorithm)对BF进行改进，BF每次都要进行全部边的判断
//1：只有当某个顶点的d[u]值改变时，从它出发的邻接点的v的d[v]的值才有可能改变
//1.1：设置一个队列，每次将队首元素取出，然后对从u出发的所有边u-》v进行松弛操作，判断是否可以，如果可行，判断v是否在队列中，不在则加入队列，直到队列为空
//错误总结：1：邻接矩阵储存图的意思，怎么获取顶点值和边权
//2:SPFA是由BF改进来的，所以对num数组进行优化时的情况也要考虑是否会进行重复计算
//3:当路径相等时相当于也进行了优化
#include<cstring>//memset在这个头文件中
#include <iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<set>
using namespace std;
int n, m;
const int maxv=510;
const int INF = 1000000000;
int weight[maxv];
struct node {//熟悉邻接表储存图的意思，什么时候获取顶点值，什么时候
    int s;//s为顶点
    int v;//表示边权：单源最短路径问题
    node(int s1, int v1) :s(s1), v(v1) {};
};
vector<node>adj[maxv];
int num[maxv], w[maxv],d[maxv];
bool inq[maxv];
set<int>pre[maxv];//记录前驱的数组
void SPFA(int s)
{
    memset(num, 0, sizeof(num));
    memset(w, 0, sizeof(w));
    memset(inq, false, sizeof(inq));
    fill(d, d + maxv, INF);
    //源点入队
    queue<int>q;
    q.push(s);
    d[s] = 0;
    w[s] = weight[s];//权值初始化
    num[s]++;
    inq[s] = true;
    while (!q.empty())
    {
        int v = q.front();
        q.pop();
        inq[v] = false;
        for (int j = 0; j < adj[v].size(); j++)
        {
            int q1 = adj[v][j].s;//获取点值
            int w2 = adj[v][j].v;//获取边权
            //进行松弛操作
            if (d[v] + w2 < d[q1])
            {
                d[q1] = d[v] + w2;
                num[q1] = num[v];//数量覆盖
                w[q1] = w[v] + weight[q1];
                pre[q1].clear();
                pre[q1].insert(v);
                //要进行判断是否在队列中
                if (!inq[q1]);
                {
                    q.push(adj[v][j].s);
                     inq[q1] = true;
                }
                
                
            }
            else if (d[v] + w2 == d[q1])
            {
                if (w[q1] < w[v] + weight[q1])
                {
                    w[q1] = w[v] + weight[q1];
                }
                pre[q1].insert(v);
                /*num[q1] += num[v];*/
                num[q1] = 0;
                //防止反复累计的值
                set<int>::iterator it;
                for (it = pre[q1].begin(); it != pre[q1].end(); it++)
                {
                    num[q1] += num[*it];
                }
                //这段也是至关重要的：此时也相当于进行了优化
                if (!inq[q1]);
                {
                q.push(adj[v][j].s);
                inq[q1] = true;
                }
            }
        }
    }

}
int main()
{
    int s, e;
    cin >> n >> m>>s>>e;
    for (int i = 0; i < n; i++)
    {
        cin >> weight[i];
    }
    int s1, e1, w1;
    for (int i = 0; i < m; i++)
    {
        cin >> s1>>e1>>w1;
        //这里是个双向图：用邻接表储存的方法
        adj[s1].push_back(node(e1, w1));
        adj[e1].push_back(node(s1, w1));
    }
    SPFA(s);
    cout << num[e] <<" "<< w[e];
    return 0;
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

4:Floyd:解决全源路径最短问题

// Floyd.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//Floyd算法目的：解决全源最短路径问题：时间复杂度为O(n^3)
//Floyd算法思路：
//1:枚举每个顶点
//2:以每个顶点为中介，判断是否可以进行优化
#include <iostream>
#include<algorithm>
using namespace std;
//定义全局变量
int n, m;//定义点数和边数
const int  MAXV= 200;//把顶点数限制在200以内
const int INF = 100000000;
int dis[MAXV][MAXV];//距离数组：表示顶点i到j的距离
//不需要定义是否访问
//F算法
void Floyd()
{
    for (int k = 0; k < n; k++)//枚举顶点：注意不要放到内层循环
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                //经过以k为中介，i到j的距离能不能缩短
                if (dis[i][k] != INF && dis[k][j] != INF && dis[i][k] + dis[k][j] < dis[i][j])
                    dis[i][j] = dis[i][k] + dis[k][j];
            }
        }
    }
}
int main()
{
    //输入顶点、边数
    
    scanf_s("%d%d", &n, &m);
    //初始化
    //1:数组进行全部初始化
    //初始化的格式写错了：应该为dis[0]
    fill(dis[0], dis[0] + MAXV * MAXV, INF);
    //2：初始距离设为0；
    //:2：自己到自己的距离初始化为0
    for (int i = 0; i < n; i++)dis[i][i] = 0;
    /*for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        { dis[i][j] = 0;}         
    }*/
    //输入边的信息
    int u, v, w;//输入顶点和边的权值
    for (int i = 0; i < m; i++)
    {
        scanf_s("%d%d%d", &u, &v,&w);
        //为什么还要定义距离矩阵呢？不能直接在邻接矩阵上进行操作吗？
        //没必要定义两个数组，直接在矩阵上进行操作
        dis[u][v] = w;
    }
    Floyd();//入口
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("%d ", dis[i][j]);
        } 
        printf("\n");

    }
    return 0;


}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
WF19980719
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单源点最短路径Dijkstra算法的JAVA实现
张新波的技术随笔
04-06 9896
在城市智能交通中,经常会用到最短路径的问题,比如找最佳的行车路线等,Dijkstra算法做为最经典的求解方法,为我们指明了方向.不过真正想让我了解该算法的原因是在学习ICTCLAS的N-最短路径算法,虽然和我们常用的案例有一点区别,但基本相同,为了更好的理解N-最短路径算法,我又重新把大学时代的数据结构知识搬了出来。在网上找到一篇文章，非常详细生动（有FLASH动画演示）的描述了该算法的实现，
Bellman-Ford算法（BF）与SPFA算法
lggg的博客
10-11 322
BF Dijkstra算法可以很好的解决无负权图，但如果出现了负权边，便会失效。 首先，图的任意一条最短路径既不能包含负权回路，也不会包含正权回路，因此它最多包含|v|-1条边。，如果把源点S作为一棵树的根结点，把其他结点按照最短路径的结点顺序连接，就会生成一棵最短路径树。 主要思路如下（伪代码）复杂度为（V*E）： for(i=0;i<n-1;i++)//n为顶点数 { ...
最短路模板BF和SPFA，poj3259测
xinge008的专栏
08-18 642
分别用BF和SPFA处理带负权图，自己写的模板，哎也WA 了N多次呀，测试题目是poj3259 Bellman-ford： #include #include #include #define MAX 1<<28 using namespace std; const int maxn=7010; int N,M,W; int dis[maxn]; int edgenum; struc
PAT甲级 - 1003 Emergency (25 分) Dijstra和BF算法
DedicateToAI的博客
11-15 196
As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the ...
算法:图的最短路径-BF算法（比普通版迪杰斯特拉快）以牛客网的单元最短路径那道题为例子
weixin_58133735的博客
04-16 389
牛客网上的单源最短路径问题
leetcode和oj-Algorithms:算法
06-30
leetcode 和 oj 算法虐我千百遍，我待算法如...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入排序 选择排序 希尔排序 快排 归并排序 堆排序 线性排序算法 桶排序 查找算法 顺序表查找：顺序
leetcode和oj-Learn-Algorithms:学习算法
06-30
leetcode 和 oj 算法虐我千百遍，我待算法如...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入排序 选择排序 希尔排序 快排 归并排序 堆排序 线性排序算法 桶排序 查找算法 顺序表查找：顺序
leetcode和oj-algorithms:业余时间刷算法
06-30
leetcode 和 oj 算法虐我千百遍，我待算法如...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入排序 选择排序 希尔排序 快排 归并排序 堆排序 线性排序算法 桶排序 查找算法 顺序表查找：顺序
leetcode和oj-AlgorithmCShap:算法Chap
06-30
leetcode 和 oj 算法虐我千百遍，我待算法如初恋 这里的内容是我学习算法过程的一些记录，希望能一直坚持...Floyd,Dijkstra,bellman-ford,spfa 排序算法 交换排序算法 冒泡排序 插入排序 选择排序 希尔排序 快排 归并排
最短路径之（迪杰斯特拉）Dijkstra算法（及其改进：BF算法，SPFA算法），(弗洛伊德)Floyd算法
是小光a~
12-01 2499
最短路径之（迪杰斯特拉）Dijkstra算法（及其改进：BF算法，SPFA算法），(弗洛伊德)Floyd算法： 1.Dijkstra算法不能解决带负权边的图 2.B-F算法做了优化允许图中出现负权边并解决该问题 3.SPFA算法利用队列对B-F算法进一步优化，允许图中可以出现环但是不能解决带环的图（仅能判别出现但是不能解决） 4.Floyd算法能解决负权边但不能解决负环
一份代码四个算法：广度优先BFS、Dijstra、最佳优先BFS、A*
ReDreamme的博客
05-14 601
算法不应是背出来的，本文非基础介绍，不会抄定义，全是一些需要思考的内容~~
最短路径算法（Floyd，Dijkstra，Blleman Ford）
m0_48630721的博客
03-19 555
最短路径算法
算法基础篇：常见图论最短路算法（Bellman-Ford→SPFA→Dijkstra Floyd-Warshall ）入门以及代码解析
一捆呆在ac篮子里的好葱，
07-12 2108
巩固基础篇：常见图论算法（Bellman-Ford→SPFS→Dijkstra Floyd-Warshall ）入门以及代码解析
算法笔记 10.4.1 最短路径 Dijkstra
树叶子的博客
05-02 507
最短路径要解决的问题 对任意给定的图G(V,E)和起点S和终点T,如何求从S到T的最短路径 Dijkstra、Bellman-Ford、SPFA、Floyd 10.4.1 Dijkstra算法 解决单源最短路径问题，即给定图G和起点s,通过算法得到S到达其他各点的最短距离 Dijkstra伪代码 //dijkstra伪代码 //G为图，一般设成全局变量...
一个用Dijkstra算法实现的路由算法的java程序——6 STDijkstraAdv类
Fe Tech
11-11 2048
import java.util.Vector;import java.util.StringTokenizer;/** * 这是一个点对点(S-T)Dijkstra算法的改进。用于求两点间的所有最短路径。 *  * @author Fe */public class STDijkstraAdv { /**  * 所求路经所在图的邻接链表引用。  */ GraphAdjList graphAdjL
一个用Dijkstra算法实现的路由算法的java程序——2 GraphFromFile类
Fe Tech
11-11 1865
import java.io.*;import java.util.*;import javax.swing.JOptionPane;/** * 类GraphFromFile用于从文件读入图的信息。 * 包括：图的结点个数及其邻接关系、图中边的权值、图中结点显示的位置坐标 * 以及各结点对应的名称。 *  * 其中有关图的邻接表文件的格式为： *  *  * [Graph] * NodeNum =
POJ 1860 Currency Exchange 最短路 BF & SPFA（bfs）
BLF2
01-21 844
Currency Exchange Time Limit: 1000MS Memory Limit: 30000K Total Submissions: 21046 Accepted: 7539 Description Several currency exchange points are working in our ci
dijkstra and floyd----- about graphic algorithm
^_^纯一狼^o^
06-10 1188
   i would like to use FLOYD since the first experiment which was hold last week.    The professor gave us  a question, about graphic algorithm:    Select a position among a certain number of vill
具有障碍物的欧几里德最短路径问题
starfish的专栏
03-22 4475
这个问题是计算几何学中的一个经典课题：具有障碍物的欧几里德最短路径问题(ESP0)ESPO可以描述如下:给定平面中两点s和t，及多边形障碍物集Ω={ω1,ω2,...,ωk}，要求由s至t并避开所有障碍物的最短路径。平面中的ESPO问题在多项式时间内可以求解，而E^3中具有多面体障碍物时确定最短路径长度的问题是NP难的。一个简单的算法如下：由s到t的最短路径是一条折线链，该链的顶点是多
最短路径问题解析：Dijkstra、Bellman-Ford与SPFA算法
"本文主要介绍了最短路径问题的解决方法，包括Dijkstra算法、Bellman-Ford算法、SPFA算法，以及Floyed-Warshall算法，并详细解析了松弛技术在这些问题中的应用。" 最短路径问题是图论中的经典问题，涉及到如何在带...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值