【大数据】SSSP算法

import heapq
 
def dijkstra(graph, source):
    distances = {vertex: float('inf') for vertex in graph}
    previous_nodes = {vertex: None for vertex in graph}
    distances[source] = 0
    nodes = list(graph.keys())
 
    while nodes:
        current_node = min(nodes, key=lambda vertex: distances.get(vertex, float('inf'))
                           if vertex in distances else float('inf'))
        nodes.remove(current_node)
 
        for neighbor, weight in graph[current_node].items():
            alternative_route = distances[current_node] + weight
            if alternative_route < distances.get(neighbor, float('inf')):
                distances[neighbor] = alternative_route
                previous_nodes[neighbor] = current_node
 
    return distances, previous_nodes
 
# 用法示例
graph = {
    'A': {'B': 10, 'C': 15},
    'B': {'C': 2, 'D': 5},
    'C': {'D': 4},
    'D': {'E': 6},
    'E': {}
}
 
distances, previous_nodes = dijkstra(graph, 'A')
print(distances)  # 输出每个节点到源点的最短路径长度
print(previous_nodes)  # 输出每个节点的前驱节点

这段代码定义了一个dijkstra函数，它接受一个图和源点作为输入，返回源点到所有其他顶点的最短路径长度和每个顶点的前驱节点。Dijkstra算法通过维护一个节点集合和一个距离标量来工作，这个集合不断扩展到新的节点，直到所有节点都包含在内。

3.2 SSSP算法JAVA实现

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
 
public class SSSP {
 
    // 用于表示最短路径的数组，dis[i]表示从起点到i节点的最短路径长度
    private int[] dis;
 
    // 构造函数，初始化dis数组
    public SSSP(int n) {
        dis = new int[n];
        Arrays.fill(dis, Integer.MAX_VALUE);
    }
 
    // 执行SSSP算法
    public void executeSSSP(int[][] graph, int start) {
        Queue<Integer> queue = new LinkedList<>();
        dis[start] = 0; // 将起点的最短路径长度设为0
        queue.offer(start); // 起点加入队列
 
        while (!queue.isEmpty()) {
            int node = queue.poll(); // 从队列中取出一个节点
            for (int i = 0; i < graph[node].length; ++i) {
                if (graph[node][i] != 0 && dis[i] > dis[node] + graph[node][i]) {
                    dis[i] = dis[node] + graph[node][i]; // 更新最短路径长度
                    queue.offer(i); // 将新节点加入队列
                }
            }
        }
    }
 
    // 获取指定节点的最短路径长度
    public int getShortestPath(int node) {
        return dis[node];
    }
 
    public static void main(String[] args) {
        int n = 5; // 节点数量
        int[][] graph = {
            {0, 1, 1, 0, 0},
            {0, 0, 0, 1, 0},
            {0, 1, 0, 1, 0},
            {0, 0, 0, 0, 1},
            {0, 0, 0, 0, 0}
        };
 
        SSSP sssp = new SSSP(n);
        sssp.executeSSSP(graph, 0); // 执行算法，从节点0开始
 
        // 打印最短路径长度
        for (int i = 0; i < n; ++i) {
            System.out.println("节点" + i + "到节点0的最短路径长度为：" + sssp.getShortestPath(i));
        }
    }
}

这段代码定义了一个SSSP类，包含初始化最短路径数组、执行SSSP算法和获取最短路径长度的方法。在main方法中，我们创建了一个简单的加权图，并从节点0开始执行SSSP算法，然后打印出所有节点到节点0的最短路径长度。

3.3 SSSP算法C++实现

#include <iostream>
#include <vector>
#include <queue>
#include <functional>
#include <limits>
 
using namespace std;
 
typedef function<int(int)> Access;
typedef vector<int> Graph;
 
void SSSP(int start, int V, const Graph& G, const Access& dist, queue<int>& Q) {
    static const int INF = numeric_limits<int>::max();
    vector<bool> used(V, false);
    vector<int> d(V, INF);
    dist = Access([&](int v) -> int { return d[v]; });
 
    d[start] = 0;
    Q.push(start);
    used[start] = true;
 
    while (!Q.empty()) {
        int u = Q.front();
        Q.pop();
        used[u] = false;
        for (int v = 0; v < V; ++v) {
            if (G[u * V + v] != INF && dist(u) + G[u * V + v] < dist(v)) {
                d[v] = dist(u) + G[u * V + v];
                if (!used[v]) {
                    Q.push(v);
                    used[v] = true;
                }
            }
        }
    }
}
 
int main() {
    int V = 5; // 顶点数
    Graph G(V * V, 10000); // 边的数量，初始化为大的值
    queue<int> Q;
    Access dist;
 
    // 构建图的例子
    // 0-1 10
    // 0-2 30
    // 0-3 1000
    // 1-2 50
    // 3-2 10
    // 3-4 20
    G[0 * V + 1] = 10;
    G[0 * V + 2] = 30;
    G[0 * V + 3] = 1000;
    G[1 * V + 2] = 50;
    G[3 * V + 2] = 10;
    G[3 * V + 4] = 20;
 
    SSSP(0, V, G, dist, Q);
 
    for (int i = 0; i < V; ++i) {
        cout << "Distance from 0 to " << i << ": " << dist(i) << endl;
    }
 
    return 0;
}

这段代码实现了SSSP算法，并展示了如何使用该算法计算图中从顶点0开始到其他所有顶点的最短路径。在这个例子中，我们假设图是有向的，边的权重为正值。代码中的SSSP函数接受起始顶点、顶点数、图的邻接矩阵以及一个访问函数和队列作为参数，并计算出最短路径。在main函数中，我们构建了一个简单的图，并调用SSSP函数来计算最短路径，最后输出了每个顶点到起始顶点的最短路径长度。

四、SSSP算法应用

SSSP算法，即单源最短路径算法，是一种在图论中广泛使用的算法，它专注于解决一个核心问题：如何从一个特定的起点出发，找到到达图中所有其他顶点的最短路径。这个算法在现实世界中的应用是多方面的，它不仅能够优化路径规划，减少资源消耗，还能显著提高效率。

想象一下，在繁忙的城市中，你正使用一款地图导航应用，希望从你的当前位置快速到达一个远距离的目的地。SSSP算法在这里发挥了关键作用，它通过分析道路网络，计算出一条或多条从起点到终点的最短路径，同时考虑到交通状况、道路类型和距离等因素。这不仅节省了你的时间，还可能帮助你避开交通拥堵，确保旅途更加顺畅。

在社交网络分析领域，SSSP算法同样具有其独特的应用价值。假设你想要了解你和某个社交网络上的朋友之间是否存在某种联系，以及这种联系的紧密程度。通过应用SSSP算法，你可以迅速找到你们之间的最短关系链，这有助于揭示社交网络中的潜在联系和影响力。

此外，在计算机网络的路由协议中，SSSP算法也扮演着至关重要的角色。数据包在网络中传输时，需要经过多个节点才能到达目的地。SSSP算法能够帮助确定最佳的传输路径，确保数据包能够以最快的速度、最少的延迟和最高的可靠性到达目标主机。这在构建高效、稳定的网络通信系统中是不可或缺的。

综上所述，SSSP算法不仅是一个理论上的数学工具，它在实际生活中有着广泛的应用，从个人的日常出行到社交网络的深度分析，再到网络通信的高效传输，SSSP算法都在默默地发挥着其强大的功能，为我们的生活带来便利。

大雨淅淅

关注

13
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
【大数据】SSSP算法

SSSP算法，即单源最短路径算法（Single-Source Shortest Path），用于在加权图中找到从单一源点到所有其他顶点的最短路径。该算法的核心目标是确定每个顶点到源点的最短路径长度，并可能同时构建出这些路径。
复制链接

扫一扫