6.图 Dijsktra, Prim,Kruskal,包括堆优化

最新推荐文章于 2022-10-05 16:46:28 发布
最新推荐文章于 2022-10-05 16:46:28 发布
阅读量184 收藏
点赞数
分类专栏： 随笔 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiguanlant/article/details/120177862
版权

特殊矩阵的压缩存储

对称矩阵的压缩存储

只存储主对角线+上\下半角

按照行优先或者列优先存储

三角矩阵的压缩存储

跟对称矩阵相同的思想

稀疏矩阵的压缩存储

  • 三元组方式存储
  • 十字链表法

图的基本概念

图G比顶点集边集日且成，记为G=(V,E)，其中v(G)表示图G中顶点的有限非空集;E(G)表示图G中顶点之间的关系（边）集合。若V={v, vs… , vn,}，则用V]表示图G中顶点的个数，也称图G的阶，E= {(u, v) | ueV,vev}，用|E|表示图G中边的条数。

最小生成树

Prim算法

从某一个顶点开始构建生成树;每次将代价最小的新顶点纳入生成树，直到所有顶点都纳入为止。

Kruskal算法

每次选择一条权值最小的边，使这条边的两头连通(原本已经连通的就不选)直到所有结点都连通

最短路径

BFS(无权图) 单源最短路径

Dijkstra(带权图， 无权图) 单源最短路径 不适合带负权的图

Floyd(带权图，无权图) 各顶点间的最短路径 不能解决带负权回路的图

拓扑排序

AOV网(Activity on vertex Network，用顶点表示活动的网)
用DAG图〈有向无环图）表示一个工程。顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于活动Vj进行

拓扑排序︰在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序:
1每个顶点出现且只出现一次。2若顶点A在序列中排在顶点B的前面，则在图中不存在从顶点B到顶点A的路径。 或定义为:拓扑排序是对有向无环图的顶点的一种排序，它使得若存在一条从顶点A到顶点B的路径，则在排序中顶点B出现在顶点A的后面。每个AOV网都有一个或多个拓扑排序序列。

逆拓扑排序：先删除入度为0的点

在带权有向图中，以顶点表示事件，以有向边表示活动，以边上的权值表示完成该活动的开销〈如完成活动所需的时间)，称之为用边表示活动的网络，简称AOE网(Activity On Edge NetWork)

关键路径

AOE网具有以下两个性质︰
①只有在某顶点所代表的事件发生后，从该顶点出发的各有向边所代表的活动才能开始; ②只有在进入某顶点的各有向边所代表的活动都已结束时，该顶点所代表的事件才能发生。另外，有些活动是可以并行进行的

在AOE网中仅有一个入度为0的顶点，称为开始顶点（源点)，它表示整个工程的开始;
也仅有一个出度为0的顶点，称为结束顶点（汇点)，它表示整个工程的结束。

从源点到汇点的有向路径可能有多条，所有路径中，具有最大路径长度的路径称为关键路径，而把关键路径上的活动称为关键活动

Graph.h

#ifndef _GRAPH_H_
#define _GRAPH_H_

#include <iostream>
#include <vector>

//无向图，邻接矩阵
class UMGraph
{
public:
    UMGraph(const int v, const int e) : __INF(99999999)
    {
        this->vertex = v; 
        this->edge = e;
        for(int i = 0; i <= vertex; ++ i)
            visited.push_back(false);
        for(int i = 0; i <= vertex; ++ i)
            graph.push_back(std::vector<int>(vertex+1, __INF));
        // for(int i = 1; i <= vertex; ++ i)
        //     graph[i][i] = 0;
    }

public:
    int getV(){ return vertex; }
    int getE(){ return edge; }
    void getGraph();

public:
    void Insert();
    bool Delete();
    void DFSTravel(std::vector<int> &);
    void BFSTravel(std::vector<int> &);
    void Dijkstra(std::vector<int> &, std::vector<int> &);
    void Dijkstraheap(std::vector<int> &, std::vector<int> &);
    void Prim(int &cost, bool flag = 1);
    void Primheap(int &cost, bool flag = 1);
    void Kruskal(int &cost);

private:
    void __Insert(const int u, const int v, const int weight);
    bool __Delete(const int u, const int v);
    void __DFSTravel(const int u, std::vector<int> &);
    void __BFSTravel(const int u, std::vector<int> &);
    void __Dijkstra(const int u, std::vector<int> &, std::vector<int> &);
    void __Dijkstraheap(const int u, std::vector<int> &, std::vector<int> &);
    void __Prim(int &cost, bool flag);
    void __Primheap(int &cost, bool flag);
    int find_father(int x, std::vector<int> &fat);
    void __Kruskal(int &cost);

public:
    int vertex, edge;
    const long long __INF;
    std::vector<bool> visited;
    std::vector<std::vector<int> > graph;
};


//无向图，邻接表



//有向图，邻接矩阵



//有向图，邻接表


#endif //_GRAPH_H_

Graph.cpp

#include "Graph.h"
#include <iostream>
#include <queue>
#include <algorithm>

void UMGraph::getGraph()
{   
    for(int i = 1; i <= vertex; ++ i)
    {
        for(int j = 1; j <= vertex; ++ j)
            std::cout << graph[i][j] << " ";
        std::cout << std::endl;
    }
}

void UMGraph::Insert()
{
    std::cout << "Input your node v form u and weight: ";
    int un, vn, w;
    std::cin >> un >> vn >> w;
    __Insert(un, vn, w);
}

void UMGraph::__Insert(const int u, const int v, const int weight)
{
    //int tmp = std::min(weight, graph[u][v]);
    graph[u][v] = graph[v][u] = std::min(weight, graph[u][v]);
}

bool UMGraph::Delete()
{
    std::cout << "Input you'll delete two nodes: ";
    int un, vn;
    std::cin >> un, vn;
    return __Delete(un, vn);
}

bool UMGraph::__Delete(const int u, const int v)
{
    if(graph[u][v] != __INF && graph[v][u] != __INF)
    {
        return false;
    }
    graph[u][v] = graph[v][u] = __INF;
    return false;
}

void UMGraph::DFSTravel(std::vector<int> &p)
{
    std::cout << "Input you'll DFSTravel first node: ";
    int un;
    std::cin >> un;
    for(auto x : visited)
        x = false;
    //std::cout << "The DFS sequence is: \n";
    __DFSTravel(un, p);
    //std::cout << "\n";
}

void UMGraph::__DFSTravel(const int u, std::vector<int> &p)
{
    visited[u] = true;
    //std::cout << u << " ";
    p.push_back(u);
    for(int i = 1; i <= vertex; ++ i)
    {
        if(!visited[i] && graph[u][i] != __INF && graph[i][u] != __INF)
        {
            visited[i] = true;
            __DFSTravel(i, p);
        }
    }
}

void UMGraph::BFSTravel(std::vector<int> &p)
{
    std::cout << "Input you'll BFSTravel first node: ";
    int un;
    std::cin >> un;
    for(auto x : visited)
        x = false;
    //std::cout << "The BFS sequence is: \n";
    __BFSTravel(un, p);
    //std::cout << "\n";
}

void UMGraph::__BFSTravel(const int u, std::vector<int> &p)
{
    //std::cout << u << " ";
    p.push_back(u);
    std::queue<int> q;
    q.push(u);
    visited[u] = 1;
    while(!q.empty())
    {
        int t = q.front();
        q.pop();
        for(int i = 1; i <= vertex; ++ i)
        {
            if(!visited[i] && graph[t][i] != __INF && graph[i][t] != __INF)
            {
                visited[i] = true;
                q.push(i);
                //std::cout << i << " ";
                p.push_back(i);
            }
        }
    }
}

void UMGraph::Dijkstra(std::vector<int> &dis, std::vector<int> &path)
{
    std::cout << "Input you'll begin from: ";
    int un;
    std:: cin >> un;
    dis.push_back(0);
    path.push_back(0);
    for(int i = 1; i <= vertex; ++ i)
    {
        dis.push_back(graph[un][i]);
        visited[i] = false;
        if(dis[i] == __INF)
            path.push_back(-1);
        else 
            path.push_back(un);
    }
    dis[un] = 0;
    visited[un] = true;
    __Dijkstra(un, dis, path);
    //std::cout << "The shortest dis from u to other is: \n";
    // for(auto x : dis)
    //     std::cout << x << " ";
    // std::cout << "\n";
    // for(auto x : path)
    //     std::cout << x << " ";
    // std::cout << "\n";
    // for(int i = 1; i <= vertex; ++ i)
    //     std::cout << dis[i] << " ";
    // std::cout << "\n";
    // for(int i = 1; i <= vertex; ++ i)
    //     std::cout << path[i] << " ";
    // std::cout << "\n";
}

void UMGraph::__Dijkstra(const int u, std::vector<int> &dis, std::vector<int> &path)
{
    for(int i = 1; i <= vertex; ++ i)
    {
        int t = u, tmp = __INF;
        for(int j = 1; j <= vertex; ++ j)
            if(!visited[j] && tmp > dis[j])
            {
                tmp = dis[j];
                t = j;
            }
        
        if(t == vertex) break;
        visited[t] = true;

        for(int j = 1; j <= vertex; ++ j)
        {
            if(!visited[j] && graph[t][j] < __INF)
            {
                if(dis[j] > dis[t]+graph[t][j])
                {
                    dis[j] = dis[t]+graph[t][j];
                    path[j] = t;
                }
            }
        }
    }
}

void UMGraph::Dijkstraheap(std::vector<int> &dis, std::vector<int> &path)
{
    std::cout << "Input you'll begin from: ";
    int un;
    std:: cin >> un;
    //占位
    dis.push_back(0);
    path.push_back(0);
    //初始化
    for(int i = 1; i <= vertex; ++ i)
    {
        dis.push_back(__INF);
        visited[i] = false;
        if(dis[i] == __INF)
            path.push_back(-1);
        else 
            path.push_back(un);
    }
    dis[un] = 0;
    __Dijkstraheap(un, dis, path);

    //std::cout << "The shortest dis from u to other is: \n";
    // for(auto x : dis)
    //     std::cout << x << " ";
    // std::cout << "\n";
    // for(auto x : path)
    //     std::cout << x << " ";
    // std::cout << "\n";
    // for(int i = 1; i <= vertex; ++ i)
    //     std::cout << dis[i] << " ";
    // std::cout << "\n";
    // for(int i = 1; i <= vertex; ++ i)
    //     std::cout << path[i] << " ";
    // std::cout << "\n";
}

void UMGraph::__Dijkstraheap(const int u, std::vector<int> &dis, std::vector<int> &path)
{
    typedef struct Node
    {
        int u, step;
        Node() {};
        Node(int a, int b) : u(a), step(b) {};
        bool operator<(const Node &t) const
        {
            return step > t.step;
        }
    }Node;

    std::priority_queue<Node> pq;
    pq.push(Node(u, 0));

    while(!pq.empty())
    {
        Node it = pq.top();
        pq.pop();
        int t = it.u;
        if(visited[t])  continue;  //找到了
        visited[t] = 1;
        for(int i = 1; i <= vertex; ++ i)
        {
            if(!visited[i] && graph[t][i] < __INF)
            {
                if(dis[i] > dis[t]+graph[t][i])
                {
                    dis[i] = dis[t]+graph[t][i];
                    path[i] = t;
                    pq.push(Node(i, dis[i]));
                }
            }
        }
    }
}

void UMGraph::Prim(int &cost, bool flag)
{
    __Prim(cost, flag);
}

void UMGraph::__Prim(int &cost, bool flag)
{
    std::vector<int> lowcost(vertex+1, 0), mit(vertex+1, 1);

    for(int i = 1; i <= vertex; ++ i)
    {
        lowcost[i] = graph[1][i];
        mit[i] = 1;
    } 
    mit[1] = 0;

    int idx = 1;

    cost = 0;

    for(int i = 2; i <= vertex; ++ i)
    {
        int minn = __INF, t = 0;
        for(int j = 2; j <= vertex; ++ j)
        {
            if(lowcost[j] < minn && lowcost[j] != 0)
            {
                minn = lowcost[j];
                t = j;
            }
        }

        if(flag == 1)
        {
            printf("%d --> %d  w: %d\n", mit[t], t, minn);
        }
        cost += minn;
        lowcost[t] = 0;

        for(int j = 2; j <= vertex; ++ j)
        {
            if(graph[t][j] < lowcost[j])
            {
                lowcost[j] = graph[t][j];
                mit[j] = t; //更新前驱
            }
        }
    }
}

void UMGraph::Primheap(int &cost, bool flag)
{
    __Primheap(cost, flag);
}


void UMGraph::__Primheap(int &cost, bool flag)
{

    typedef struct node
    {
        int weight, u;
        node(int w, int u1) : weight(w), u(u1) {};
        bool operator<(const node &a) const
        {
            return weight > a.weight;
        }
    }node;
    std::vector<int> path(vertex+1, -1);
    path[1] = 1;
    std::vector<int> lowcost(vertex+1, __INF);
    for(int i = 0; i <= vertex; ++ i)
    {
        visited[i] = 0;
        lowcost[i] = __INF;
    }
    cost = 0;

    std::priority_queue<node> pq;

    pq.push(node(0, 1));

    while(!pq.empty())
    {
        node t = pq.top();
        pq.pop();
        int d = t.weight, v = t.u;

        if(visited[v]) continue;
        visited[v] = true;
        cost += d;
        for(int i = 1; i <= vertex; ++ i)
        {
            if(!visited[i] && lowcost[i] > graph[v][i])
            {
                lowcost[i] = graph[v][i];
                pq.push(node(lowcost[i], i));
                path[i] = v;
            }
        }
    }
    if(flag == 1)
    {
        for(int i = 1; i <= vertex; ++ i)
            std::cout << path[i] << " ";
        std::cout << "\n";
    }
}

int UMGraph::find_father(int x, std::vector<int> &fat)
{
    if(fat[x] != x)
        return find_father(fat[x], fat);
    return x;
}

void UMGraph::Kruskal(int &cost)
{
    __Kruskal(cost);
}

void UMGraph::__Kruskal(int &cost)
{
    std::vector<int> fat(vertex+1, 0);
    for(int i = 1; i <= vertex; ++ i)
        fat[i] = i;
    typedef struct Edge
    {
        int u, v, w;
        bool operator<(const Edge &a) const
        {
            return w < a.w;
        }
    }Edge;

    Edge arr[edge+1];
    int idx = 1;
    for(int i = 1; i <= vertex;  ++ i)
    {
        for(int j = i; j <= vertex; ++ j)
        {
            if(graph[i][j] != __INF)
            {
                arr[idx].u = i; arr[idx].v = j; arr[idx].w = graph[i][j];
                idx ++;
            }
        }
    }
    // for(int i = 1; i <= edge; ++ i)
    //     std::cout << arr[i].u << " " << arr[i].v << " " << arr[i].w << "\n";
    std::sort(arr+1, arr+1+edge);
    // std::cout << "\n";
    // for(int i = 1; i <= edge; ++ i)
    //     std::cout << arr[i].u << " " << arr[i].v << " " << arr[i].w << "\n";
    // std::cout << "\n";    
    int num = 0;
    for(int i = 1; i <= edge; ++ i)
    {
        if(num == vertex-1) break;
        int u, v, w;
        u = arr[i].u; v = arr[i].v; w = arr[i].w;
        if(find_father(u, fat) != find_father(v, fat))
        {
            fat[find_father(u, fat)] = find_father(v, fat);
            cost += w;
            num ++;
        }
    }   
}
xiguanlant
关注
专栏目录
xiaochong.rar_Dijsktra
09-22
在"xiaochong.rar"压缩包内的"Dijsktra"实现可能包括以下部分： - `Graph`类：表示图的结构，可能包含节点和边的数据结构，以及添加边、获取邻接节点等方法。 - `Node`类：表示图中的节点，包含节点的标识和当前...
图有关算法(prim、kruskal、dijkstra)
程序狗的成长之路
11-16 1066
1.定义概览 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，如数据结构，图论，运筹学等等。注意该算法要求图中不存在负权边。 问题描述：在无向图 G=(V,E) 中，假设每条边 E[i] 的长
最小生成树 Kruskal 和 Prim算法及堆优化
m0_60777643的博客
05-12 2756
解决最小生成树的问题之前，我们先要明白生成树/最小生成树是什么。 对一个具有 n 个点的连通图进行遍历，对于遍历后的子图，其包含原图中所有的点且保持图连通，最后的结构一定是一个具有 n-1 条边的树，通常称为生成树。 如果是连通网，则生成树 边的权就是每条边的权的总和。所谓最小生成树，也就是权最小的生成树。一个图的生成树不唯一 在生成树问题中，最常见的问题就是最小生成树问题，所谓最小生成树，就是对于一个有 n 个点的无向连通图的生成树，其包含原图中的所有点，且保持图连通的边权总和...
【模板】最小生成树——堆优化的Kruskal
m0_52325450的博客
07-27 141
如题，给出一个无向图，求出最小生成树，如果该图不连通，则输出orz。
Prim算法求最小生成树(c++)个人记录向
Yu_iChan的博客
10-05 716
但是这个prim算法却支持负权边，其实还是一个概念问题，我们的最小生成树，要的是n个点，n-1的条边，所以就算有负权边，也就两种情况，要么开始就出现了然后被加入了最小生成树，要么后来出现，但是需要经过一条边给拐回去，这样就会造成不是n-1条边会多出边，就不是最小生成树了。Prim算法和dijkstra算法十分十分之相似，但是他们最最重要的区别就在于这个dis数组，dijkstra算法的dis数组表示的是到1号点的距离，而这里求最小生成树的prim算法的dis数组表示的是到已经确定了的集合的距离。
四个常用的最短路算法及其细节和应用
m0_60777643的博客
05-17 1481
一.Dijkstra 单源最短路 Dijkstra算法是常用的求单源最短路的算法，他可以求出固定源点到图中其他所有点的最短路。但是他的缺陷也很明显，Dijkstra的缺陷就在于它不能处理负权回路：Dijkstra对于标记过的点就不再进行更新了，所以即使有负权导致最短距离的改变也不会重新计算已经计算过的结果 1.普通模板O(n^2) 其实思路和最小生成树Prim算法很像，都是从一个起点开始，设定为白区，然后不断向外拓展节点，同时更新到外部蓝区的距离。 但是区别在于Prim维护一个dis数.......
基于Dijsktra算法的最短路径求解_C语言_Dijsktra_
10-01
迪杰斯特拉（Dijkstra）算法是图论中一个经典的最短路径算法，由荷兰计算机科学家艾兹格·迪杰斯特拉在...在实践中，可以尝试对算法进行优化，比如使用二叉堆或斐波那契堆提高效率，或者针对具体问题进行针对性改进。
Dijsktra_迪杰斯特拉算法_迪杰特斯拉_Dijsktra_
09-29
这个算法主要用于解决单源最短路径问题，即从图中的一点（源点）出发，找到到达其他所有点的最短路径。在计算机科学中，它常用于路由算法、网络流量优化和许多其他与路径查找相关的应用。 迪杰斯特拉算法的基本思想...
dijsktra模板最短路径[文].pdf
10-11
Dijkstra算法是一种常用的图算法，用于计算图中从源点到所有其他点的最短路径长度。该算法的实现主要依赖于三个数组：dist、prev和c。其中，dist数组用于存储当前点到源点的最短路径长度，prev数组用于记录当前点的...
Project12_最短路径_Dijsktra_
10-02
在"Project12_最短路径_Dijsktra_"项目中，可能包含以下内容： 1. `main.cpp` 或其他源代码文件：实现迪杰斯特拉算法的代码，包括读取图的邻接矩阵，初始化距离和优先队列，以及执行算法的过程。 2. `graph.h` 或...
Prim(普利姆算法)
mycsdn_dada的博客
09-24 433
Prim(普利姆算法) 学习视频 尚硅谷数据结构与算法 普利姆算法是为解决最小生成树问题的一种算法，最小生成树（Minimum Cost Spanning Tree），简称MST，给定一个带权的无向连通图，选取一颗树使树上所有边的权值之后最小，通俗来讲就是在n个节点的无向连通图中找出一个包含n个节点的最小连通子图，且子图没有回路。 算法流程 设G=（V,E）是连通图，T=（U,D）是最小生成树，V,U是顶点集合，E,D是边集合。 若从顶点v开始构造最小生成树，将顶点v从集合V中取出放入集合U，设置vi
Kruskal算法求最小生成树 (最小堆优化）
QiaoRuoZhuo的专栏
02-28 2601
实现了 Kruskal算法求最小生成树 (三元组边表集）的最小堆优化算法。 关于并查集的算法，参见《一种简单而有趣的数据结构——并查集》
最小生成树kruskal算法（贪心+并查集+堆优化）
ReidSC的博客
03-10 2644
kruskal算法克鲁斯卡尔算法的基本思想是以边为主导地位，始终选择当前可用（所选的边不能构成回路）的最小权植边。所以Kruskal算法的第一步是给所有的边按照从小到大的顺序排序。这一步可以直接使用库函数qsort或者sort。接下来从小到大依次考察每一条边（u，v）。具体实现过程如下：&lt;1&gt;　设一个有n个顶点的连通网络为G（V,E），最初先构造一个只有n个顶点，没有边的非连通图T={...
最小生成树算法——Kruskal算法、Prim算法、堆优化的Prim算法
热门推荐
anlian523的博客
08-27 1万+
什么叫最小生成树？ 已知一个无向连通图，那么这个图的最小生成树是该图的一个子图，且这个子图是一棵树且把图中所有节点连接到一起了。一个图可能拥有多个生成树。一个带权重的无向连通图的最小生成树（minimum spanning tree），它的权重和是小于等于其他所有生成树的权重和的。 生成树的权重和，是把生成树的每条边上的权重加起来的和。 一颗最小生成树有多少条边？ 已知带权重无向连通图有V...
最小生成树入门 kruskal和堆优化的prim
Lily1221的博客
03-21 257
定义：给定一个无向图，如果它的某个子图中的任意两个顶点都互相连通并且是一棵树，那么这棵树就叫生成树（Spanning Tree）如果边存在权值，那么使得边权和最小的生成树叫做最小生成树（MST Minimum Spanning Tree）。 求最小生成树的算法有两种：Prim和Kruskal。Prim在稠密图中效率更高，Kruskal在稀疏图中效率更高。 Prim类似于Dijkstr...
[分析](最小生成树：Prim堆优化，Kruskal)poj1258 Agri-Net
10-22 691
传送门：poj1258 Agri-Net 最小生成树模板题，借着这道题再重新整理下最小生成树。 算法：Prim 和 Kruskal  1.Prim：从任一节点出发，不断扩展 使用数据结构：堆 时间复杂度：O(ElogV)或O(VlogV+E)(斐波那契堆) 适用于密集图 若不用堆，则时间复杂度为O(V^2) 2.Kruskal:将所有边从小到大加入，在此过程中判断是否构成回路 使...
Kruskal算法（最小生成树）
Mango.
07-26 5129
Kruskal算法（最小生成树）
运用并查集与最小堆实现Kruskal算法
razorEdge的博客
12-01 4352
前言 Kruskal是在一个图（图论）中生成最小生成树的算法之一。（另外还有Prim算法，之后会涉及到）这就牵扯到了最小生成树的概念，其实就是总权值最小的一个连通无回路的子图。（结合下文的示意图不难理解）这里的代码并没有用图的存储结构（如：矩阵，邻接链表等）来处理和运用这个算法，而是最简单的三元组输入，这样会使得这个过程简化很多，至于图的存储方式，在之后总结图数据结构的时候会具体讨论。Kruska
【最小生成树】Kruskal - Prim - 堆优化的Prim
Anadem‘s Blog
03-27 300
文章目录写在前面题目 C - 掌握魔法の东东 Iinputoutputsample inputSample Outputkruskaldijskra堆优化的dijstra 写在前面 整理了一份最小生成树算法板子 题目 C - 掌握魔法の东东 I 东东在老家农村无聊，想种田。农田有$ n$ 块，编号从 1~nnn。种田要灌氵 众所周知东东是一个魔法师，他可以消耗一定的 MP 在一块田上施展魔法，使得...
某省共有10个大中城市，各城市之间的高速公路交通示意图如下图所示（单位：km），在城市3建有该省的物资集散中心，物资将从这里出了，运往该省的其他城市.参考Dijsktra算法,请找出从城市3到各个城市之间的最短距离，并设计相应的行车路线.
最新发布
06-09
根据题目所给的高速公路交通示意图，我们可以将城市和它们之间的距离表示为一个带权有向图。接下来，我们可以使用Dijkstra算法来找出从城市3到各个城市之间的最短距离。 Dijkstra算法的基本思想是维护一个集合S，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值