【最短路径】

#include <stdio.h>
#include <string.h>
#define Max 100
int vexNum, arcNum;
int vexs[Max], arcs[Max][Max];
int INF = 0xffff;
int final[Max], path[Max], d[Max];
int D[Max][Max], Path[Max][Max];
void dijkstra(int v){
    int i, j, k, min, p, m, b[Max];
    final[v] = 1;
    for(i = 0; i < vexNum; i++)
        if(i != v){
            d[i] = arcs[v][i];
            path[i] == arcs[v][i] < INF ? v : -1;
            final[i] = 0;
        }
    for(i = 0; i < vexNum; i++){
        min = INF;
        for(j = 0; j < vexNum; j++)
            if(!final[j] && d[j] < min){
                min = d[j];
                k = j;
            }
        final[k] = 1;
        for(j = 0; j < vexNum; j++)
            if(!final[j] && arcs[k][j] < INF && arcs[k][j] + d[k] < d[j]){
                d[j] = arcs[k][j] + d[k];
                path[j] = k;
            }
    }
    for(i = 0; i < vexNum; i++)
        if(i != v){
            printf("%d %d\n", v, i);////////////////
            p = path[i];
            if(p == -1)
                printf("no\n");
            else
            {
                m = 0;
                b[m++] = i;//////////
                while(p != v){
                    b[m++] = p;/////////////////
                    p = path[p];
                }
                b[m] = v;/////////////
                for(j = m; j > 0; j--)
                    printf("%d->", b[j]);//////////////
                printf("%d,%d\n", b[0], d[i]);
            }
        }
}
void floyd(){
    int i, j, k, p, m, b[Max];
    for(i = 0; i < vexNum; i++)
        for(j = 0; j < vexNum; j++){
            D[i][j] = arcs[i][j];
            if(i != j && arcs[i][j] < INF)
                Path[i][j] = i;
            else
                Path[i][j] = -1;
        }
    for(k = 0; k < vexNum; k++)
        for(i = 0; i < vexNum; i++)
            for(j = 0; j < vexNum; j++)
                if(D[i][k] + D[k][j] < D[i][j]){
                    D[i][j] = D[i][k] + D[k][j];
                    Path[i][j] = Path[k][j];
                }
    for(i = 0; i < vexNum; i++)
        for(j = 0; j < vexNum; j++)
            if(i != j){
                printf("%d %d\n", i, j);
                p = Path[i][j];
                if(p == -1)
                    printf("no\n");
                else{
                    m = 0;
                    b[m++] = j;
                    while(p != i){
                        b[m++] = p;
                        p = Path[i][p];
                    }
                    b[m] = i;
                    for(k = m; k > 0; k--)
                        printf("%d->", b[k]);
                    printf("%d %d\n", b[0], D[i][j]);
                }
            }
}
int main(int argc, char *argv[]){
    int i, j, v1, v2;
    scanf("%d%d", &vexNum, &arcNum);
    for(i = 0; i < vexNum; i++)
        scanf("%d", &vexs[i]);
    for(i = 0; i < vexNum; i++)
        for(j = 0; j < vexNum; j++)
            arcs[i][j] = INF;
    for(i = 0; i < arcNum; i++){
        scanf("%d%d", &v1, &v2);
        scanf("%d", &arcs[v1][v2]);
    }
    dijkstra(0);
    //floyd();
    return 0;
}
/*
3 5
0 1 2

0 1 4
0 2 11
1 0 6
1 2 2
2 0 3
*/
时间: 2024-10-20 17:57:51

【最短路径】的相关文章

ACM: HDU 3790 最短路径问题-Dijkstra算法

HDU 3790 最短路径问题 Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Description 给你n个点,m条无向边,每条边都有长度d和花费p,给你起点s终点t,要求输出起点到终点的最短距离及其花费,如果最短距离有多条路线,则输出花费最少的. Input 输入n,m,点的编号是1~n,然后是m行,每行4个数 a,b,d,p,表示a和b之间有一条边,且其长度为d,花费为p.最后一行是

最短路径算法专题1----弗洛伊德

由于最短路径算法我认为比较重要,所以分成几个专题来慢慢细化去磨它,不能一口气吃个胖子嘛. 首先在说算法之前,先说清楚什么叫做最短路径. 题目一般会给你一张图,然后告诉你很多地方,然后告诉你各个地方之间的路程有多远,要你求出,两点间的最短距离,注意,题目给出的两点间的距离未必是最短的,可能通过第三个点转换之后达到更短.实际其实也是这样的,有时候两个地方并没有直线的道路只有曲线的绕路. 算法的思路: 1.用二维数组列出所有的距离,达到不了的用最大距离表示,如9999999 2.循环数组上面的每一个点

postgresql+postgis+pgrouting实现最短路径查询(1)---线数据的处理和建立拓扑

准备一个线shp数据,并将其导入postgres里面,postgres安装postgis和pgrouting两个插件(方法见http://www.cnblogs.com/nidaye/p/4553522.html).线数据的字段如下:注意字段的名称,省的出现不必要的麻烦. 1.ALTER TABLE beijing_line ADD COLUMN source integer; ALTER TABLE beijing_line ADD COLUMN target integer; ALTER T

算法导论——最短路径Dijkstra算法

package org.loda.graph; import org.loda.structure.IndexMinQ; import org.loda.structure.Stack; import org.loda.util.In; /** * * @ClassName: Dijkstra * @Description: Dijkstra最短路径算法--贪心算法 * @author minjun * @date 2015年5月27日 下午4:49:27 * */ public class D

最短路径(四)—Bellman-Ford的队列优化(邻接表)

上一节我们写了Bellman-Ford算法解决负权边的问题: 邻接表存储图: n个顶点,m条边. 数组实现邻接表.对每一条边进行1-m编号.用u,v,w三个数组来记录每条边的信息,即u[i],v[i],w[i]表示第i条边是从第 u[i]号顶点到v[i]号顶点且权值为w[i]. first数组的1-n号单元格分别用来存储1-n号顶点的第一条边的编号,初始的时候因为没有边加入所有都是-1.即first[u[i]]保存顶点u[i]的第一条边的编号,next[i]存储"编号为i的边"的&qu

最短路径(Floyd法)

最短路径法: 算法的主要思想是:单独一条边的路径也不一定是最佳路径. 从任意一条单边路径开始.所有两点之间的距离是边的权的和,(如果两点之间没有边相连, 则为无穷大). 对于每一对顶点 u 和 v,看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比己知的路径更短.如果是更新它. 先把所有的结果都计算出来放在数组里面,然后根据需要输出所需要的两点之间的最短路径.用了三个循环来实现 还有一个要Mark一下的是:不如一个数组s[i][j]:那可以用这个数组来存放三个数 i,j和s[i][j]:

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

图结构中应用的最多的就是最短路径的查找了,关于最短路径查找的算法主要有两种:迪杰斯特拉算法(Dijkstra)和Floyd算法. 其中迪杰斯特拉算法(Dijkstra)实现如下: 原理就是不断寻找当前的最优解: void main() { int V[Max][Max]={0,8,32,Infinity,Infinity, 12,0,16,15,Infinity, Infinity,29,0,Infinity,13, Infinity,21,Infinity,0,7, Infinity,Infi

[BZOJ 1576] 安全路径 最短路径树 路径压缩

题意 给定一张 n 个点 m 条边的图, 保证对于任意的点 i , 从点 1 到点 i 的最短路唯一. 对于任意的点 i , 询问: 将 1 到 i 的最短路中最后一条边删去之后, 从 1 到 i 的最短路 . n <= 100000, m <= 200000 . 分析 首先跑 Dijsktra , 构建出最短路径树. 接下来考虑每条非树边 E[p] = (u, v, d) 对答案的影响, 它能且仅能影响到点 u, v 之上, LCA(u, v) 之下的点的答案. (包括 u, v, 不包括

四大最短路径算法比较

  Floyd Dijkstra Bellman-Ford 队列优化的Bellman-ford 空间复杂度 O(N²) O(M) O(M) O(M) 时间复杂度 O(N3) O((M+N)logN) O(NM) O(NM) 适用情况 稠密图,和顶点关系密切 稠密图,和顶点关系密切 稀疏图,和边关系密切 稀疏图,和边关系密切 负权 可以解决 不能解决 可以解决 可以解决 注1:N为定点数,M为边数 注2:  Floyd的编码复杂度较小,均摊到每个点上的时间复杂度并不算太高,如果是求所有点对间的最短

Floyd算法 - 最短路径

2017-07-27 22:21:04 writer:pprp 该算法的本质是动态规划,形式简单,复杂度高为O(n^3): d[i][j] = max(d[i][k]+d[k][j],d[i][j]); 采用的基本手段是松弛 适用:解决多源最短路径问题 代码如下: #include <iostream> using namespace std; const int maxn = 200; int n,s,t; int a[maxn+1][maxn+1]; void init() { int m