【算法笔记】最短路径——单源最短路径,Dijsktra算法(贪心算法)

适用条件

  • 有向图 or 无向图
  • 非负权(所有边权都 ⩾ \geqslant 0 )
  • 单源最短路径(给定源点s,求s到其他顶点的最短路径)

使用到的数据结构

  • 集合S:记录所有已经找到最短路径的节点
    • 初始时S中只有一个节点 S={s}
    • 迭代结束时S为所有源点s可以到达的节点的集合
      • 此时如果目标节点t不在集合S中,就认为从源点s无法到达t
    • 每一轮迭代选出一个新的节点加入集合S中,即每一次迭代都能为一个新的节点找到最短路径
  • 数组distdist[p] 是目前为止能够从集合S到达节点p的最短距离
    • dist数组的长度等于图中的节点数n,即每一个节点i都有一个对应的dist[i]值,因此理论上来讲需要迭代n次,为每一个节点都找到最短路径
    • 在每一轮迭代中,从所有尚未找到最短路径的节点(不在集合S中的节点)中选出dist值最小的一个,加入集合S,并根据选出的节点更新dist数组的内容
    • 如果在某一轮迭代时,剩余节点的dist值都是INF,说明剩余节点都是不可达的,此时可以直接终止循环迭代的过程
    • 当算法迭代完之后,dist[i]即为从源点s到节点i的最短路径的长度
    • 初始化:
      • dist[s] = 0: s到自身的距离为0
      • dist[i] = edge[s][i]:对于能够从源点s直达的节点i,dist[i]等于直达边的权重
      • dist[else] = INF
  • 数组path:path[i]记录「与dist[i]对应的路径(一条从s到i的路径)」的倒数第二个节点(即节点i的上一个节点),用于回溯最短路径
    • 初始化:
      • path[s] = -1 (路径回溯终止标志)
      • path[源点s的直达节点] = s
    • 如果在算法迭代完之后想要获取到达节点i的最短路径:
      • 最短路径的最后一个节点为last_1 = i
      • 最短路径的倒数第二个节点为last_2 = path[last_1] = path[i]
      • 最短路径的倒数第三个节点为last_3 = path[last_2]
      • 如果遇到某一个节点,其对应的path值为-1,即回溯到了源点s,此时整条最短路径已经获得,可以终止回溯过程

例子

在这里插入图片描述在这里插入图片描述

SEUOJ_1028

在这里插入图片描述

  • 无向图
  • 可能有重复边,因为是求最短路径,所以只需要保存两点之间权值最小的边即可
  • 节点编号从1开始
#include <iostream>
#include <stdio.h>
#include <climits>
#include <iomanip>
#include <set>
#include <queue>
using namespace std;

const int MAXN = 500, MAXE = 10000;
const int INF = INT_MAX;

int n, E, s, t; 
int edges[MAXN+1][MAXN+1]; // edges[u][v] == INF: u与v之间无边 

void print_test_input(){
    cout << "edges:" << endl;
    for(int i=1; i<=n; i++){
        for(int j=1; j<=n; j++){
            if(edges[i][j] != INF)
                cout << setw(5) << edges[i][j];
            else 
                cout << setw(5) << "INF";
        }
        cout << endl;
    }
}

void input(){
    cin >> n >> E >> s >> t;
    // 重置edges数组
    for(int i=0; i<=n; i++){
        for(int j=0; j<=n; j++){
            edges[i][j] = INF;
        }
    }
    
    // 读图   
    int u, v, w;
    for(int i=0; i<E; i++){
        cin >> u >> v >> w;
        // edges[u][v] = min(edges[u][v], w); // 有向图
        edges[u][v] = edges[v][u]= min(edges[u][v], w); // 无向图
    }
}

set<int> S;
int dist[MAXN+1];
int path[MAXN+1];

void print_test_dijkstra(){
    cout << "S:";
    for(set<int>::iterator it=S.begin(); it!=S.end(); it++) 
        cout <<  *it << " ";
    cout << endl;

    cout << "dist:";
    for(int i=1; i<=n; i++){
        if(dist[i] == INF) cout << "INF ";
        else cout << dist[i] << " ";
    }
    cout << endl;
}

void dijkstra(){
    // 初始化
    S.clear();
    S.insert(s);

    for(int i=1; i<=n; i++){
        dist[i] = INF;
    }
    dist[s] = 0;
    path[s] = -1;
    for(int i=1; i<=n; i++){
        if(edges[s][i] != INF){
            dist[i] = edges[s][i];
            path[i] = s;
        }
    }

    // print_test_dijkstra();

    // 迭代n-1次,为除S外每一个节点都找到最短路径
    for(int i=1; i<n; i++){
        // 从所有尚未找到最短路径的节点(不在集合S中的节点)中选出dist值最小的一个
        int min_dist = INF, min_dist_p = -1;
        for(int j=1; j<=n; j++){
            if(S.find(j)==S.end() && dist[j] < min_dist){
                min_dist = dist[j];
                min_dist_p = j;
            }
        }
        // 将min_dist_p加入S中
        S.insert(min_dist_p);
        // 根据min_dist_p更新dist中的内容准备进行下一轮迭代
        for(int j=1; j<=n; j++){
            if( S.find(j) == S.end()
            && edges[min_dist_p][j] != INF
            && min_dist+edges[min_dist_p][j] < dist[j]){
                dist[j] = min_dist+edges[min_dist_p][j];
                path[j] = min_dist_p;
             }
        }
        // print_test_dijkstra();
    }
}

queue<int> min_path;

bool print_min_path(int t){
    if(dist[t] == INF){
        return false;
    }
    
    min_path.push(t);
    while(path[t] != -1){
        min_path.push(path[t]);
        t = path[t];
    }
    cout << "min path: ";
    while(!min_path.empty()){
        cout << min_path.back() << " ";
        min_path.pop();
    }
    cout << endl;
    return true;
}

int main(){
    // freopen("test.txt", "r", stdin);

    int T;
    cin >> T;
    for(int i=0; i<T; i++){
        input();
        // print_test_input();
        dijkstra();
        if(dist[t] != INF){
            cout << dist[t] << endl;
        }else{
            cout << -1 << endl;
        }
        // print_min_path(t);
    }

    return 0;
}
  • 0
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
离字典,将起始节点的距离设为0,其他节点的距离设为无穷大 distances = {node: sys.maxsize for node in graph} distances[start] = 0 # 初始化已访问节点的集合和未访以下是使用问节点D的集ijkstra合 visited = set() unvisited算法求解最短路径的Python = set(graph) while unvisited: # 代码示例: ```python class D选择当前ijkstra距: def __init__(self, graph离最小的节点 , start, current goal): self.graph = graph # 邻接表_node = min(unvisited, key=lambda self node: distances[node]) # 更新.start = start当前节点的 # 起邻居节点点 self.goal =的距离 goal # 终点 for neighbor in graph self.open[current_node]: _list = {} if neighbor in # open 表 self.closed_list unvisited: new_distance = distances[current_node] + = {} graph[current_node][neighbor # closed 表 self.open_list[start] if new_distance] = < distances[neighbor]: 0.0 # 将 distances[neighbor] = new_distance # 将当前起点放入 open_list 中 self.parent = {节点标记start:为已访 None} 问,并从未访问集合中移除 visited.add # 存储节点的父子关系。键为(current_node) 子节点, unvisited值为父.remove(current_node) return节点。方便做最 distances def print后_path(dist路径的ances,回 start溯 self.min, end): _dis = None # 根 # 最短路径的长度 def shortest_path据距离字典和终点节点(self): while True: ,逆向 if self打印路径.open_list is path = [end None: ] print('搜索 current_node =失败 end while current_node !=, 结束!') break distance start: , min_node = for neighbor in graph min(zip[current_node]: if(self.open_list distances[current.values(), self_node] ==.open_list.keys distances[neighbor())) #] + graph 取出距[neighbor][current_node]: 离最小的节点 self path.open_list.pop.append(min_node)(neighbor) current_node = neighbor break path.reverse() # 将其从 open_list 中去除 self print.closed("_list[minShortest_node] = path from", distance # 将节点加入 closed start, "to", end,_list ":", "->".join(path)) # 示例 中 if min_node == self.goal: # 如果节点为图的邻接矩阵终点 self.min_dis = distance 表示 graph shortest = { _path = [ 'Aself.goal]': {'B': # 5, 'C 记录从': 终1}, 点回溯的路径 'B

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值