最短路问题

一 Dijkstra算法

/*HDU2544
Input
每组数据第一行是两个整数N、M(N<=100,M<=10000)N表示成都的大街上有几个路口,
标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。
N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1<=A,B<=N,1<=C<=1000),
表示在路口A与路口B之间有一条路,我们的工作人员需要C分钟的时间走过这条路。
Output
对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间
Sample Input
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
Sample Output
3
2
*/
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define INF 0x3f3f3f3;
int map[110][110],dis[110],visited[110];

void Dijkstra(int n,int x)
{
    int i,p,j,min;
    for (i=1; i<=n; i++)
    {
        dis[i]=map[1][i];
        visited[i]=0;
    }
    visited[x]=1;
    for (i=1; i<=n; i++)
    {
        min=INF;
        for (j=1; j<=n; j++)
        {
            if(!visited[j] && dis[j]<min)
            {
                p=j;
                min=dis[j];
            }
        }
        visited[p]=1;
        for (j=1; j<=n; j++)
        {
            if(!visited[j] && dis[p]+map[p][j]<dis[j])
            {
                dis[j]=dis[p]+map[p][j];
            }
        }
    }
}

int main()
{
    int n,m,i,j,a,b,t;
    while(scanf("%d%d",&n,&m),n+m)
    {
        for (i=1; i<=n; i++)
        {
            for (j=1; j<=n; j++)
            {
                map[i][j]=INF;
            }
        }
        for(i=1; i<=m; i++)
        {
            scanf("%d%d%d",&a,&b,&t);
            map[a][b]=map[b][a]=t;
        }
        Dijkstra(n,1);
        printf("%d\n",dis[n]);
    }
    return 0;
}

HDU2544

过程如图所示,求解单源最短路问题(固定起点),基于贪心算法

二 Floyd算法

#include <iostream>
#include <cstdio>
using namespace std;
const int INF=0x3f3f3f3f;
int dis[110][110];
int main()
{
    int i,j,k,n,m,p,q,s;
    while(scanf("%d%d",&n,&m),n+m)
    {
        for (i=1; i<=n; i++)
        {
            for(j=1; j<=n; j++)
            {
                dis[i][j]=INF;
            }
        }
        for (i=0; i<m; i++)
        {
            scanf("%d%d%d",&p,&q,&s);
            dis[p][q]=dis[q][p]=s;
        }
        for (k=1; k<=n; k++)
        {
            for (i=1; i<=n; i++)
            {
                for (j=1; j<=n; j++)
                {
                    if (dis[i][j]>dis[i][k]+dis[k][j])
                    {
                        dis[i][j]=dis[i][k]+dis[k][j];
                    }
                }
            }
        }
        printf("%d\n",dis[1][n]);
    }
    return 0;
}

HDU2544

Floyd算法是求任意两点间的最短路径的一种算法,可以正确处理有向图或负权的最短路径问题,基于动态规划

时间: 2024-11-04 09:29:58

最短路问题的相关文章

最短路问题(Bellman/Dijkstra/Floyd)

最短路问题(Bellman/Dijkstra/Floyd) 寒假了,继续学习停滞了许久的算法.接着从图论开始看起,之前觉得超级难的最短路问题,经过两天的苦读,终于算是有所收获.把自己的理解记录下来,可以加深印象,并且以后再忘了的时候可以再看.最短路问题在程序竞赛中是经常出现的内容,解决单源最短路经问题的有bellman-ford和dijkstra两种算法,其中,dijikstra算法是对bellman的改进.解决任意两点间的最短路有Floyd-warshall算法. 单源最短路1(bellman

P103 Dijkstra算法 单源最短路问题优化算法

///标准的dijkstra算法 void dijkstra() { while(true) { int vert=-1; dis[-1]=INF; for(int i=0;i<num_v;i++) { if( (!used[i]) && ( vert==-1||dis[i]<dis[vert] ) ) {vert=i;} } if(vert==-1) break;///这里要提前break;好像是这样... used[vert]=1; for(int i=0;i<num

P100 单源最短路问题 Bellman-Ford 算法

///单源最短路问题 ///DAG:单向不循环图 ///问题的特殊性:要对变进行遍历,而不是顶点 const int MAX_V=; const int MAX_E=; const int INF=; int num_v; int num_e; int start; int aim; struct edge { int from; int to; int cost; }; edge G[MAX_E]; int dis[MAX_V]; void min_path(int start) { for(

UVA 10986 Sending email 最短路问题

基本的最短路问题 就是数据需要稍微处理一下.(N比较大)dijkstra也要优化.不优化应该会T: #include <map> #include <set> #include <list> #include <cmath> #include <ctime> #include <deque> #include <stack> #include <queue> #include <cctype> #i

编程算法 - 单源最短路问题 Bellman-Ford 代码(C)

单源最短路问题 Bellman-Ford 代码(C) 本文地址: http://blog.csdn.net/caroline_wendy 单源最短路: 固定一个起点, 求它到其他所有点的最短路的问题. Bellman-Ford: 设当前到顶点i的最短路长度为d[i], 并设初值d[s]=0, d[i]=INF, 再不断使用递推关系式d[e.to] = d[e.from] + e.cost更新d的值. 时间复杂度: O(V*E) 代码: /* * CppPrimer.cpp * * Created

最短路问题专题

///注意:最短路问题均没有使用递归函数. /* Dijkstra 单源最短路问题 用了一个队列 Bellman_Ford 单源最短路 暴搜 Floyd_warshanll 多元最短路问题 dp 直接更新 Dijkstra算法的路径还原*/ Dijkstra算法 Bellman_Floyd算法 Floyd_warshall算法 单源最短路问题 对所有的边进行遍历,更新d的数字 Bellman——floyd 暴力破解 === const int MAX_E; const int MAX_V; co

寒假集训日志(一)——图,最短路问题

今天主要学习了图的有关内容,以及DFS,BFS,最短路问题的大致讲解,做了4道习题,完成了今日任务. 最短路的三种算法: 1.Dijkstra算法(使用连接矩阵,打起来简单,但是复杂度高) 2.Bellman Ford算法(松弛操作, 使用较少) 3.SFPA算法(第一种算法的优化,使用最多) 另外,求两个点之间的最短路:Floyd算法 今天做的4道题: A - 最短路 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:

最短路问题(floyd算法)(优化待续)

问题描述: 最短路问题(short-path problem):若网络中的每条边都有一个数值(长度.成本.时间等),则找出两节点(通常是源节点和阱节点)之间总权和最小的路径就是最短路问题.最短路问题是网络理论解决的典型问题之一,可用来解决管路铺设.线路安装.厂区布局和设备更新等实际问题. 1.floyd算法 算法描述: Floyd算法又称为插点法,是一种用于寻找给定的加权图中多源点之间最短路径的算法.该算法名称以创始人之一.1978年图灵奖获得者.斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名.

单源最短路问题 bellman-ford算法

贴一个链接将最短路问题的:http://www.cnblogs.com/Yan-C/p/3916281.html Bellman-Ford算法寻找单源最短路径的时间复杂度为O(V*E). 这个算法是基于动态规划的思想.也就是利用现在的最小路径去更新其他路径的最小距离. 有个要点就是要对边进行松弛操作,其实就是更新路径吧~ 用dis数组来存储这个点到起点的最小距离.用一个struct来存储每一条边的信息. 算法步骤: 1.对图进行初始化,dis[]=INF , dis[s] = 0;s表示起点.