【最短路】Bellmanford算法及链式前向星存图

既然学完动态规划了:01dp  多重dp
我们接着刷板子:最短路问题
最短路有很多种,这次我们先刷Bellmanford算法

先从图的存储方式说吧,以后每写一篇最短路就写一种存图的方式,这次是“链式前向星”
其实是一个很好理解的问题,因为一个节点指向其他节点的图长得就很像一个星星

话不多说,直接上我最开始学的代码,我认为可读性还是可以的

#include <iostream>
#include <vector>
using namespace std;
struct Edge{
    int next,goal,value;//上一个的位置,下一个节点,权值
};
vector<Edge>edge;
int cnt=0;
vector<int>head;
void addEdge(int u,int v,int w)//添加边,u起点,v终点,w边权
{
    edge[cnt].goal=v;
    edge[cnt].value=w;
    edge[cnt].next=head[u];//给定上一条边的编号(下标
    head[u]=cnt++;//更新编号,并且使cnt增加
}
int main()
{
    int n,m;cin>>n>>m;//n个节点,m条边
    edge.resize(m);
    head.assign(m,-1);//初始化,如果值为-1说明这是该节点的第一个输入的边
    int u,v,w;
    for(int i=0;i<m;i++)
    {
        cin>>u>>v>>w;
        addEdge(u,v,w);
    }
    for(int i=1;i<=n;i++)//遍历输出,优先以每个节点开始
    {
        cout<<i<<endl;
        for(int j=head[i];j!=-1;j=edge[j].next)
        {
            cout<<i<<" "<<edge[j].goal<<" "<<edge[j].value<<endl;
        }
        cout<<endl<<endl;
    }
    
    return 0;
}

这个代码可以读入一张n个节点m条边的图,并且按照出发点将边存储进图,你可以自己进行尝试

addEdge:链式前向星的重要实现部分,每次函数调用都会将数据存入结构体数组,并且将edge[i].next更新为上一个起始边为i的下标,应该是不难理解的,对吧(

如果看懂了,那我们开始简化这个代码,直接将addEdge函数放进main函数的读入中

ll next;
    for(int i=0;i<m;i++)
    {
        cin>>next>>edge[i].goal>>edge[i].value;
        edge[i].next=head[next];
        head[next]=i;
    }

对于存图的内容我们基本就理解到位了,接下来开始寻路的内容(敲黑板
 

寻路的部分非常简单,就是对每条边进行贪心比如说现在有如下数据

则我们可以进行一次贪心操作(也被称作松弛操作)

也就是的这条路比1-->3更短,所以我们直接记录1到3的最短路径为1-->2-->3,也就是长度由4变为3,于是我们新开一个数组,记录每个点到原点的距离,每次向外松弛一次,这个操作模式有点类似bfs

上代码

vector<ll>dist(n+1,INT_MAX);//记录原点到每个点距离,且初始到原点无限远
dist[1]=0;//起点到起点的距离为0
    for(ll x=1;x<=k;x++)//松弛至多k次,通常情况下k=n-1
    {   
        vector<ll> tempDist=dist;//为了不影响之前状态,防止出现错误,所以复制一份
        for(ll i=1;i<=n;i++)
        {
            if(dist[i]==INT_MAX)continue;//经过X条边不能到达则跳过不必要循环
            for(ll j=head[i];j!=-1;j=edge[j].next)
            tempDist[edge[j].goal]=min(tempDist[edge[j].goal],dist[i]+edge[j].value);
            //松弛操作
        }
        dist=tempDist;
    }
    if(dist[n]==INT_MAX)cout<<"impossible"<<endl;//不能经过k条路到达n
    else cout<<dist[n]<<endl;

每次松弛只向外松弛一层(多走过一条边),所以可以通过外层循环对于经过边的数量进行限制
内层循环就是链式前向星的遍历

### Bellman-Ford算法的实现与原理 #### 原理说明 Bellman-Ford算法的核心思想在于逐步松弛每条边,从而更新从源节点到目标节点的短路径估计值。初始状态下,除了源节点外的所有节点的距离被设为无穷大。随后,在多 \( |V| - 1 \) 次迭代中,每次遍历所有的边并对它们进行松弛操作。如果某次迭代后仍然能够进一步减少某个节点的距离,则表明在负权环[^5]。 此外,该算法的一个显著特点是它可以处理带有负权边的结构,这是许多其他短路算法所不具备的能力[^1]。 #### 算法伪代码 以下是Bellman-Ford算法的一种常见实现方式: ```python def bellman_ford(graph, source): # 初始化距离数组 distance = {node: float('inf') for node in graph} predecessor = {node: None for node in graph} distance[source] = 0 # 进行 V-1 次松弛操作 for _ in range(len(graph) - 1): for u in graph: for v, weight in graph[u]: if distance[u] + weight < distance[v]: distance[v] = distance[u] + weight predecessor[v] = u # 检测负权环 for u in graph: for v, weight in graph[u]: if distance[u] + weight < distance[v]: raise ValueError("Graph contains a negative-weight cycle") return distance, predecessor ``` 在此代码片段中,`graph` 是一个邻接表表示的加权有向,其中 `graph[u]` 表示从节点 `u` 出发的所有边及其对应的权重列表[(v1, w1), (v2, w2)...]。函数终返回两个字典:一个是记录各节点短路径长度的 `distance` 字典;另一个是记录前驱节点以便重建路径的 `predecessor` 字典[^3]。 #### 局限性和改进建议 尽管Bellman-Ford算法功能强大,但它的时间复杂度较高,达到 \( O(|V||E|) \),这使得它在大规模稀疏上的表现不如Dijkstra等基于优先队列的方法高效。为了提高效率,可以引入SPFA(Shortest Path Faster Algorithm),这是一种利用队列优化的版本,通常能更快收敛于解集[^4]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值