[数据结构]单源最短路径

一、什么是最短路径?
对于非网图(没有边上的权值),它的最短路径指两顶点之间经过的边数最少的路径。
对于网图,它的最短路径指两顶点之间经过的权值之和最少的路径。(我们称路径上的第一个顶点是源点,最后一个顶点是终点。)
二、如何实现找到最短路径?
1、Floyd-Warshall(弗洛伊德和沃舍尔共同发明的)算法:从源点到终点允许经过1~n号所有顶点进行中转,求任意两点之间的最短路径。
特点:时间复杂度:O(N的3次方),适用于稠密图和顶点关系密切。

///邻接矩阵实现Floyd-Warshall算法核心语句
for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
       for(int j=1;j<=n;j++)
          if(e[i][j]>e[i][k]+e[k][j]) 
             e[i][j]=e[i][k]+e[k][j];

2、迪杰斯特拉(Dijkstra)算法:按路径长度递增的顺序逐步产生最短路径的构造算法。其主要的基本思想:把图中所有的顶点分成两组,第一组为已确定最短路径的顶点;第二组为未确定最短路径的顶点,按最短路径长度递增的顺序逐个把第二组的顶点加到第一组去,直到从v1出发可以到达所有顶点都在第一组中。(通过“边”来松弛1号顶点到其余各个顶点的路程,也就是更新dis)

for(int i=1;i<=n;i++) dis[i] = e[1][j];///初始化dis
///邻接表实现迪杰斯特拉(Dijkstra)算法
for(int i=1;i<=n-1;i+1){
     min = inf;///inf为无穷大
     for(int j=1;j<=n;j++)///找离1号顶点距离(边权值和)最短的顶点
        if(!visited[j]&&dis[j]<min){
        min=dis[j];
        u=j;///记录好当前顶点编号
        }
        visited[u]=1;
        for(int v=1;v<=n;v++)
           if(e[u][v]<inf&&dis[v]>dis[u]+e[u][v]) 
               dis[v]=dis[u]+e[u][v];
 }

3、Bellman-Ford(贝尔曼-福特)算法:它的基本思想与Dijkstra差不多,但是它优点在于可以处理存在负权边的图。

//数组u:边的起点
//数组v:边的终点
//数组w:边的权值
///Bellman-Ford算法核心语句
for(int k=1;k<=n-1;k++)
     for(int i=1;i<=m;i++)
         if(dis[v[i]]>dis[u[i]]+w[i])
             dis[v[i]] =dis[u[i]]+w[i];
///j检测负权回路
///本来dis已经全部更新为最小,如果判断dis还能小,必定负权边
bool flag=false;
for(int i=1;i<=m;i++)
      if(dis[v[i]]>dis[u[i]]+w[i]) flag=true;
if(flag) printf("此图含有负权回路");

bool visited[maxn]={false};///初始化为false
 for(int i=1;i<=n;i++) dis[i]=INF;初始化为无穷大

typedef struct{
   int u,v,w;
   int next;///存储当前结点邻接点的下标,也叫下一条边
}e[maxn];
int first[maxn]={-1};///初始化未-1,为第一条边编号(下边)

///Bellman-Ford队列优化,此法也叫SPFA
int spfa(int s){
      queue<int> q; 
      dis[s] = 0; 
      q.push(s); 
      visited[s] = true; 
     while(!q.empty()) { 
          int x = q.front(); 
          q.pop(); 
          inq[x] = false;
          for(int i = first[x]; i !=-1 ; i = e[i].next) {
              int k = e[i].v;
              if(dis[k] > dis[x] + e[i].w) {
                 dis[k] = dis[x] + e[i].w;
                 if(!visited[k]) {
                     visited[k] = true;
                     q.push(k);
                 }
             }
         }
      }
}

三、经典例题
未完待续.......

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单源最短路径是指从图中的一个源点出发,到达图中其他所有顶点的最短路径数据结构中常用的两种单源最短路径算法是Dijkstra算法和Bellman-Ford算法。 1. Dijkstra算法: Dijkstra算法是一种贪心算法,用于解决带权有向图或无向图的单源最短路径问题。该算法的基本思想是:将图中的所有顶点分成两个集合,一个集合为已求出最短路径的顶点集合S,另一个为未求出最短路径的顶点集合V-S。初始时,集合S中只有源点,即S={v},V-S为除源点外的其他顶点。然后,从V-S中选择与源点距离最短的顶点u,将其加入到S中,并更新从源点v到集合V-S中所有顶点的距离。重复执行该过程,直到集合V-S为空。 2. Bellman-Ford算法: Bellman-Ford算法是一种动态规划算法,用于解决带权有向图或无向图的单源最短路径问题。该算法的基本思想是:对于图中的任意一条边(u,v),如果存在从源点s到u的最短路径,则从源点s到v的最短路径就是从源点s到u的最短路径加上边(u,v)的权值。因此,Bellman-Ford算法通过对所有边进行松弛操作,不断更新从源点s到各个顶点的最短路径估计值,直到所有边的松弛操作都无法使最短路径估计值发生变化为止。 下面是两种算法的Python实现: 1. Dijkstra算法: ```python import heapq def dijkstra(graph, start): # 初始化距离字典和堆 dist = {node: float('inf') for node in graph} dist[start] = 0 heap = [(0, start)] # 循环直到堆为空 while heap: # 弹出堆中距离最小的顶点 (d, node) = heapq.heappop(heap) # 如果该顶点已经处理过,则跳过 if d > dist[node]: continue # 遍历该顶点的所有邻居 for neighbor, weight in graph[node].items(): # 计算从起点到该邻居的距离 distance = dist[node] + weight # 如果该距离比已有的距离小,则更新距离字典和堆 if distance < dist[neighbor]: dist[neighbor] = distance heapq.heappush(heap, (distance, neighbor)) return dist ``` 2. Bellman-Ford算法: ```python def bellman_ford(graph, start): # 初始化距离字典 dist = {node: float('inf') for node in graph} dist[start] = 0 # 循环V-1次,对所有边进行松弛操作 for i in range(len(graph) - 1): for u in graph: for v, weight in graph[u].items(): if dist[u] + weight < dist[v]: dist[v] = dist[u] + weight # 检查是否存在负权回路 for u in graph: for v, weight in graph[u].items(): if dist[u] + weight < dist[v]: raise ValueError("Graph contains negative weight cycle") return dist ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值