SDUT 2143 图结构练习——最短路径

最新推荐文章于 2024-05-16 17:29:33 发布
最新推荐文章于 2024-05-16 17:29:33 发布
阅读量574 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhidetian/article/details/51620389
本文提供了几种经典的图算法实现，包括Flyod、Dijkstra、Bellman-Ford及其优化版和SPFA算法，通过C++代码详细展示了如何求解单源最短路径问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

点击打开题目链接

//Flyod
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int Edge[10010][10010];

int main()
{
    int n, m;
    while(cin >> n >> m, n&&m)
    {
        for(int i = 1; i<=n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
             (i == j) ? Edge[i][j] = 0 : Edge[i][j] = INF;
            }
        }
        while(m--)
        {
            int u, v, w;
            cin >> u >> v >> w;
            if(Edge[u][v] > w)
            Edge[u][v] = Edge[v][u] = w;
        }
        for(int k = 1; k <= n; k++)
        {
            for(int i = 1; i <= n; i++)
            {
                if(Edge[i][k] != INF)
                {
                    for(int j = 1; j <= n; j++)
                    {
                        Edge[i][j] = min(Edge[i][k]+Edge[k][j], Edge[i][j]);
                    }
                }
            }
        }
        cout <<  Edge[1][n] << endl;
    }
    return 0;
}

//Dijkstra
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int Edge[110][110];
int path[110];//路径记录（需要时记录）
int dis[110];
bool vis[110];
int n, m;

void Dijkstra(int st);

int main()
{
    while(cin >> n >> m)
    {
        memset(vis, 0, sizeof(vis));
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                (i == j) ? Edge[i][j] = 0 : Edge[i][j] = INF;
            }

        }
        int u, v, w;
        while(m --)
        {
            cin >> u >> v >> w;
            if(Edge[u][v] > w)
            {
                Edge[u][v] = Edge[v][u] = w;
            }
        }
        Dijkstra(1);
    }
    return 0;
}


void Dijkstra(int st)
{

    for(int i = 1; i <= n; i++)
    {
        dis[i] = Edge[st][i];//源点到每个顶点的最短路径的长度
        if(i != st && dis[i] < INF)
        {
            path[i] = st;
        }
        else
        {
            path[i] = -1;
        }
    }
    vis[st] = 1, dis[st] = 0;
    for(int i = 1; i < n; i++)//从顶点st确定n-1条最短路径
    {
        int tmp = INF, pos;
        for(int j = 1; j <= n; j++)
        {
            if(!vis[j] && dis[j] < tmp)//选择具有最短路径的顶点pos
            {
                tmp = dis[pos = j];
            }
        }
        vis[pos] = 1;
        for(int k = 1; k <= n; k++)//修改剩下未访问顶点的dis
        {
            if(!vis[k] && Edge[pos][k] < INF && dis[pos]+Edge[pos][k] < dis[k])
            {
            dis[k] = min(dis[k], Edge[pos][k]+dis[pos]);
            path[k] = pos;
            }
        }
    }
    cout << dis[n] << endl;
}


//Bellman-Ford
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int n, m;
//int path[110];
int Edge[110][110];
int dis[110];

void Bellman_Ford(int st);

int main()
{
    while(cin >> n >> m)
    {
        memset(Edge, INF, sizeof(Edge));
        while(m --)
        {
            int u, v, w;
            cin >> u >> v >> w;
            if(Edge[u][v] > w)
            {
                Edge[u][v] = Edge[v][u] = w;
            }
        }
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                if(i == j)
                {
                    Edge[i][j] = 0;
                }
                else if(Edge[i][j] == 0)
                {
                    Edge[i][j] = INF;
                }
            }
        }
        Bellman_Ford(1);

    }
    return 0;
}


void Bellman_Ford(int st)
{
    for(int i =  1; i <= n; i++)
    {
        dis[i] = Edge[st][i];//初始化经过一条边的dis[u]的值就是Edge[st][u]
    }
     for(int k = 2; k <= n-1; k++)//经过k条边到达点u,修改dis(1)[u]递归出dis(2)[u],．．．．dis(n-1)[u]
    {//dis(1)[u]表示经过１边到u的最短距离，．．．dis(n-1)[u]表示经过n-1条边到u的最短距离
　　　//假设a -> c 被 a -> b -> c路径dis更新后，也许会出现d使得a -> b -> d -> c的距离dis更短
         for(int u = 1; u <= n; u++)//修改每个顶点的dis[u]
        {
            if(u != st)
            {
                for(int j = 1; j <= n; j++)//考虑其他顶点
                {
                    if(Edge[j][u] < INF && dis[j] + Edge[j][u] < dis[u])//顶点j到顶点u有直接路径，且途径顶点j可以是的dis[u]缩短
                    {
                        dis[u] = dis[j] + Edge[j][u];
                    }
                }
            }
        }
    }
    cout << dis[n] << endl;
}


//Bellman-Ford优化
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

struct edge
{
  int u, v, w;
}Edge[101000];

int n, m;
int dis[1010];

void Bellman_Ford(int st);

int main()
{
    while(cin >> n >> m)
    {
        memset(Edge, INF, sizeof(Edge));
        for(int i = 1; i <= m; i++)
        {
            int u, v, w;
            cin >> u >> v >> w;
            Edge[i].u = u, Edge[i].v = v , Edge[i].w = w;
            Edge[i+m].u = v, Edge[i+m].v = u , Edge[i+m].w = w;//无向图
        }
        Bellman_Ford(1);
    }
    return 0;
}


void Bellman_Ford(int st)
{
    for(int i =  1; i <= n; i++)
    {
        dis[i] = INF;
    }
    dis[st] = 0;
    for(int k = 2; k <= n; k++)
    {
        for(int i = 1; i <= 2*m; i++)
        {
        if(dis[Edge[i].u] != INF  &&  dis[Edge[i].u] + Edge[i].w < dis[Edge[i].v])
                        dis[Edge[i].v] = dis[Edge[i].u] + Edge[i].w;
        }
    }
    cout << dis[n] << endl;
}


//SPFA
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int Edge[110][110];
int n, m;
int flag, ans;

queue<int > Q;
bool vis[110];
int dis[110];

void SPFA(int st);

int main()
{
    int u, v, w;
    while(~scanf("%d %d", &n, &m))
    {
        memset(Edge, INF, sizeof(Edge));
        while(m --)
        {
            scanf("%d %d %d", &u,  &v,  &w);
            if(Edge[u][v] > w)
            {
              Edge[u][v] = Edge[v][u] = w;
            }
        }
        SPFA(1);
    }
    return 0;
}

void SPFA(int st)
{
    int tmp;
    memset(dis, INF, sizeof(dis));
    memset(vis, 0, sizeof(vis));
    vis[st] = 1, dis[st] = 0;
    Q.push(st);
    while(!Q.empty())
    {
        tmp = Q.front();
        Q.pop();
        vis[tmp] = 0;
        for(int i = 1; i <= n; i++)
        {
          if(Edge[tmp][i] < INF && dis[tmp] + Edge[tmp][i] < dis[i])
          {
            dis[i] = dis[tmp] + Edge[tmp][i];
            if(!vis[i])
            {
              vis[i] = 1;
             Q.push(i);
            }
          }
        }
    }
    printf("%d\n", dis[n]);
}


图结构练习——最短路径（Floyd算法）
Galaxy_fan的博客
08-23 745
图结构练习——最短路径Time Limit: 1000MS Memory Limit: 65536KBProblem Description 给定一个带权无向图，求节点1到节点n的最短路径。Input 输入包含多组数据，格式如下。 第一行包括两个整数n m，代表节点个数和边的个数。(n<=100) 剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。Output
图结构练习——最短路径（Dijkstra算法）
Dmenghu的博客
08-17 627
图结构练习——最短路径 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 给定一个带权无向图，求节点1到节点n的最短路径。 Input 输入包含多组数据，格式如下。 第一行包括两个整数n m，代表节点个数和边的个数。(n&amp;amp;lt;=100) 剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边...
图结构练习——最短路径
KLSZM的博客
09-14 267
图结构练习——最短路径 Description 给定一个带权无向图，求节点1到节点n的最短路径。 Input 输入包含多组数据，格式如下。 第一行包括两个整数n m，代表节点个数和边的个数。(n<=100) 剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。 Output 每组输出占一行，仅输出从1到n的最短路径权值。（保证最短路径存在） Sample Input 3 2 1 2 1 1 3 1 1 0 Output 1 0 ac代码 #include #include &
SDUTACM 图结构练习——最短路径
Key_MQL的博客
08-15 432
题目描述  给定一个带权无向图，求节点1到节点n的最短路径。   输入  输入包含多组数据，格式如下。 第一行包括两个整数n m，代表节点个数和边的个数。(n 剩下m行每行3个正整数a b c，代表节点a和节点b之间有一条边，权值为c。   输出  每组输出占一行，仅输出从1到n的最短路径权值。（保证最短路径存在）   示例输入 3 2 1 2 1
图结构练习——最短路径 （Dijkstra算法版）
weixin_54699118的博客
02-20 3745
Dijkstra算法 定义：迪克斯特拉算法，是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 这里解决最短路径问题需要先了解Dijkstra算法，所以这里先把个人对于这个算法的理解附上，再解决最短路问题。 以这个图为例，从1号走到7号的最短路径明显是从1到4再到7，这条路径的权值最小。从代码角度就要利用Dijkstra算法来解释。 因为是从1号开始走，所以
SDUT：Python实验五——函数、模块和包编程题（参考答案）
m0_73819718的博客
04-27 1198
7-3. sdut-列表或元组的数字元素求和（yeild)7-2. sdut-列表数字元素加权和(2)7-6. sdut-oop-8 分数四则运算。7-5. sdut-求指定层的元素个数。7-4. sdut-学生互助组队。7-7. sdut-分数加减法。7-1. sdut-求全排列。
SDUT：Python实验四——序列结构单选题（参考答案）
m0_73819718的博客
04-17 2487
31. 字典对象的( )方法可以获取指定“键”对应的“值”，并且可以在指定“键”不存在的时候返回指定的默认值，如果不指定则返回None。A.list("123") B.tuple("123") C.set("123") D.以上都不是。A.s1的大小小于s2的大小 B.s1的元素比s2的小 C.s1是s2的真子集 D.s2是s1的真子集。请指出程序执行结果中的问题。A.值集合 B.键集合 C.键-值对集合 D.对象。
SDUT：Python实验四——序列结构判断题（参考答案）
m0_73819718的博客
04-17 1576
38. 可以利用内置函数list()、tuple()、dict()、set()、frozenset()把其它类型的数据转换成为列表、元组、字典、可变集合和不可变集合，但不能创建空列表、空元组、空字典和空集合。23.使用Python列表的方法insert()为列表插入元素时，会改变列表中插入位置之后元素的索引。11.下面的程序当输入是 c d e a时，输出是 a c d e。19.切片L[0:3]和L[:3]含义相同，都是截取L对象的前3个元素。21.元组是可变的列表，它具有列表的大多数性质。
SDUT：Python实验六——面向对象编程题（参考答案）
最新发布
m0_73819718的博客
05-16 1014
7-6 sdut-oop-7 答答租车系统（类的继承与多态 面向对象综合练习）7-3 sdut-oop-5 计算长方体和四棱锥的表面积和体积（类的继承）7-5 sdut-oop-9 计算长方形的周长和面积（类和对象）7-1 sdut-oop-2 Shift Dot(类和对象）7-4 sdut-oop-6 计算各种图形的周长（多态）7-2 sdut-谁是最强的女汉子。
C语言练习题-最短路径.c
07-17
營火晚會上，所有同學任選一條長度1～40不等的繩索，圍成一個圓圈以進行活動。其中一個活動為目測某位同學到 所有同學的最短距離，也就是串連該同學與其他同學的最短繩索長度。例如在下列圖中，8 位同學（編號0到7） 圍成一 圈，0號同學到2號同學距離為 20+30=50。但0號同學到4號同學最短距離為25+15+20+10=70。而0號同學所有其他同學 (0號到7號)的最短距離分別為0, 20, 30, 20, 70, 60, 40, 25。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值