算法——无向图的最短路径算法

最新推荐文章于 2024-04-15 14:37:00 发布
最新推荐文章于 2024-04-15 14:37:00 发布
阅读量8k 收藏 19
点赞数 2
分类专栏： 算法与数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45927758/article/details/106819663
版权

https://www.jb51.net/article/154796.htm

我是看上面的文章写的程序，他的第一种解法还需要我再理解理解！！

 

BFS一层层寻找目标节点的算法

思路：

1.先从v到u的使用BFS遍历一遍图，得到每个节点到v的最短距离，使用数组first记录；

2.再从v到u的使用BFS遍历一遍图，得到每个节点到u的最短距离leastpath，同时判断first[v]-每一个节点的leastpath，看是否等于每一个节点对应的first数组的值。

3.如果相等，说明当前节点是最小路径的其中一个节点，但是当前算法也有缺憾，就是如果u与v之间有多条最短路径。那么就会出错，这个BUG我目前没有想出解决的办法。

下面程序只能计算无向无权图的一条最短路径，并且该图有且只能有一条最短路径！！很拉跨！

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
//边表节点
typedef struct ArcNode
{
    int Adjvex;
    ArcNode*next=nullptr;
    ArcNode(int x,ArcNode*p):Adjvex(x),next(p) {}
} ArcNode;
//顶点表节点
typedef struct VerNode
{
    int Vervex;
    ArcNode*First_Edge;
    VerNode(int x,ArcNode*p):Vervex(x),First_Edge(p) {}
} VerNode;
class chart
{
private:
    vector<VerNode*>VerNode_List;
    vector<int>Visited_Mark;
public:
    chart() {}
    void make(vector<int>data,int Road_Nums);
    void Print();
    void BFS(int v,int u);
    void Reset();
    ~chart();
};
void chart::make(vector<int>data,int Road_Nums)
{
    VerNode*Node_Pointer_temp;
    ArcNode*Arc_Pointer;
    int i,j,k;
    int Data_Len=data.size();
    for(i=0; i<Data_Len; i++)
    {
        Node_Pointer_temp=new VerNode(data[i],nullptr);
        VerNode_List.push_back(Node_Pointer_temp);
        Visited_Mark.push_back(0);
    }
    for(k=0; k<Road_Nums; k++)
    {
        cout<<"请输入无向图的路径i——j"<<endl;
        cout<<"请输入i:  ";
        cin>>i;
        cout<<endl<<"请输入j:  ";
        cin>>j;
        cout<<endl;
        Arc_Pointer=new ArcNode(j,VerNode_List[i]->First_Edge);
        VerNode_List[i]->First_Edge=Arc_Pointer;
        Arc_Pointer=new ArcNode(i,VerNode_List[j]->First_Edge);
        VerNode_List[j]->First_Edge=Arc_Pointer;
    }
}
void chart::Print()
{
    ArcNode*s;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        //cout<<VerNode_List[i]->Vervex;
        s=VerNode_List[i]->First_Edge;
        while(s!=nullptr)
        {
            cout<<" "<<VerNode_List[i]->Vervex<<"——"<<s->Adjvex<<" ";
            s=s->next;
        }
        cout<<endl;
    }
}
chart::~chart()
{
    ArcNode*s;
    ArcNode*q;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        s=VerNode_List[i]->First_Edge;
        delete VerNode_List[i];
        while(s!=nullptr)
        {
            q=s;
            s=s->next;
            delete q;
        }
    }
}
void chart::BFS(int v,int u)
{
    int node=VerNode_List.size();

    //第一遍遍历时，存储各个节点到v节点的最短路径长度
    vector<int>first(node);
    //v节点到自身的距离为0
    first[v]=0;

    VerNode*t;//定点表指针
    ArcNode*tu;//边表指针
    int idx;//记录相连节点下标

    queue<VerNode*>op;
    int q_len;//队列长度

    Visited_Mark[v]=1;
    op.push(VerNode_List[v]);

    int floor=0;//记录离源点的最小层数

    while(!op.empty())
    {
        q_len=op.size();
        floor++;
        for(int i=0; i<q_len; i++)
        {
            t=op.front();
            op.pop();
            for(tu=t->First_Edge; tu!=nullptr; tu=tu->next)
            {
                idx=tu->Adjvex;
                if(Visited_Mark[idx]!=1)
                {
                    Visited_Mark[idx]=1;
                    first[idx]=floor;
                    op.push(VerNode_List[idx]);
                }
            }
        }
    }

    //第一次层序遍历没有问题
    cout<<endl<<"我先打印一下最短的路径长度："<<first[u]<<endl;


    //重置节点状态
    Reset();
    floor=0;
    //存储最短路径的数组
    vector<int>res;
    res.push_back(u);
    //再从u开始往回遍历
    Visited_Mark[u]=1;
    op.push(VerNode_List[u]);
     while(!op.empty())
    {
        q_len=op.size();
        floor++;
        for(int i=0; i<q_len; i++)
        {
            t=op.front();
            op.pop();
            for(tu=t->First_Edge; tu!=nullptr; tu=tu->next)
            {
                idx=tu->Adjvex;
                if(Visited_Mark[idx]!=1)
                {
                    Visited_Mark[idx]=1;
                    op.push(VerNode_List[idx]);
                    if((first[u]-floor)==first[idx])
                    {
                        res.push_back(idx);
                    }
                }
            }
        }
    }
    for(int i=0;i<res.size();i++)
        cout<<res[i]<<" ";
}
void chart::Reset()
{
    int i=0;
    for(i=0; i<Visited_Mark.size(); i++)
        Visited_Mark[i]=0;
}
int main()
{
    vector<int>qaq= {0,1,2,3,4,5,6,7};
    chart wow;
    wow.make(qaq,9);
    wow.Print();
    wow.BFS(0,2);
    return 0;
}

运行截图：

目前使用DFS，BFS遍历出所有路径的方法，以及Dijkstra,Floyd算法来求得最短路径的方法还不会，以及上面这段程序还有BUG要更改！！

下面是使用Dijkstra算法来对一个带权无向图进行计算最短路径，不带权的图直接就可以把所有弧的权值设置为1，同样可以计算。

Dijkstra算法

思路：

1.从一个单源节点开始计算，寻找当前节点周围没有遍历过的邻接点，并且把当前单源节点设置为以访问状态；

2.如果从当前节点到这些邻接点的距离更短，那么更新这些邻接点的父节点数组为当前节点，距离数组为当前节点的距离数组+这些邻接点与当前节点之间弧的权重；

3.并且在遍历当前节点的邻接点的时候，要选出当前节点与这些邻接点之间弧权重最短的那个邻接点作为下一次的单源节点；

4.对下一次的单元节点的操作与上面操作类似；

5.以上操作需要借助队列来实现。

代码：

#include<iostream>
#include<vector>
#include<queue>
#include<climits>
using namespace std;
//边表节点
typedef struct ArcNode
{
    int Adjvex;
    ArcNode*next=nullptr;
    int wet;
    ArcNode(int x,ArcNode*p,int y):Adjvex(x),next(p),wet(y) {}
} ArcNode;
//顶点表节点
typedef struct VerNode
{
    int Vervex;
    ArcNode*First_Edge;
    VerNode(int x,ArcNode*p):Vervex(x),First_Edge(p) {}
} VerNode;
class chart
{
private:
    vector<VerNode*>VerNode_List;//存储图的每一个节点数据
    vector<int>Visited_Mark;//存储访问数据的情况

    vector<int>Parent;//存储节点的上一个父亲节点
    vector<int>Distance;//存储源节点到每一个节点的最短距离
public:
    chart() {}
    void make(vector<int>data,int Road_Nums);
    void Print();
    void BFS(int v,int u);//这是一个对无权最短路径计算不完全的算法，很有局限性
    void Reset();
    void Dijkstra(int u);
    ~chart();
};
void chart::make(vector<int>data,int Road_Nums)
{
    VerNode*Node_Pointer_temp;
    ArcNode*Arc_Pointer;
    int i,j,k,w;
    int Data_Len=data.size();
    for(i=0; i<Data_Len; i++)
    {
        Node_Pointer_temp=new VerNode(data[i],nullptr);
        VerNode_List.push_back(Node_Pointer_temp);
        Visited_Mark.push_back(0);
        Parent.push_back(-1);
        Distance.push_back(INT_MAX);
    }
    for(k=0; k<Road_Nums; k++)
    {
        cout<<"请输入无向图的路径i——j，以及权重"<<endl;
        cout<<"请输入i:  ";
        cin>>i;
        cout<<endl<<"请输入j:  ";
        cin>>j;
        cout<<endl<<"请输入i——j之间弧的权重";
        cin>>w;
        cout<<endl;
        Arc_Pointer=new ArcNode(j,VerNode_List[i]->First_Edge,w);
        VerNode_List[i]->First_Edge=Arc_Pointer;
        Arc_Pointer=new ArcNode(i,VerNode_List[j]->First_Edge,w);
        VerNode_List[j]->First_Edge=Arc_Pointer;
    }
}
void chart::Print()
{
    ArcNode*s;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        //cout<<VerNode_List[i]->Vervex;
        s=VerNode_List[i]->First_Edge;
        while(s!=nullptr)
        {
            cout<<" "<<VerNode_List[i]->Vervex<<"——"<<s->Adjvex<<" ";
            s=s->next;
        }
        cout<<endl;
    }
}
chart::~chart()
{
    ArcNode*s;
    ArcNode*q;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        s=VerNode_List[i]->First_Edge;
        delete VerNode_List[i];
        while(s!=nullptr)
        {
            q=s;
            s=s->next;
            delete q;
        }
    }
}
void chart::BFS(int v,int u)//说实话，这段算法其实很有局限性嗷
{
    int node=VerNode_List.size();

    //第一遍遍历时，存储各个节点到v节点的最短路径长度
    vector<int>first(node);
    //v节点到自身的距离为0
    first[v]=0;

    VerNode*t;//定点表指针
    ArcNode*tu;//边表指针
    int idx;//记录相连节点下标

    queue<VerNode*>op;
    int q_len;//队列长度

    Visited_Mark[v]=1;
    op.push(VerNode_List[v]);

    int floor=0;//记录离源点的最小层数

    while(!op.empty())
    {
        q_len=op.size();
        floor++;
        for(int i=0; i<q_len; i++)
        {
            t=op.front();
            op.pop();
            for(tu=t->First_Edge; tu!=nullptr; tu=tu->next)
            {
                idx=tu->Adjvex;
                if(Visited_Mark[idx]!=1)
                {
                    Visited_Mark[idx]=1;
                    first[idx]=floor;
                    op.push(VerNode_List[idx]);
                }
            }
        }
    }

    //第一次层序遍历没有问题
    cout<<endl<<"我先打印一下最短的路径长度："<<first[u]<<endl;


    //重置节点状态
    Reset();
    floor=0;
    //存储最短路径的数组
    vector<int>res;
    res.push_back(u);
    //再从u开始往回遍历
    Visited_Mark[u]=1;
    op.push(VerNode_List[u]);
     while(!op.empty())
    {
        q_len=op.size();
        floor++;
        for(int i=0; i<q_len; i++)
        {
            t=op.front();
            op.pop();
            for(tu=t->First_Edge; tu!=nullptr; tu=tu->next)
            {
                idx=tu->Adjvex;
                if(Visited_Mark[idx]!=1)
                {
                    Visited_Mark[idx]=1;
                    op.push(VerNode_List[idx]);
                    if((first[u]-floor)==first[idx])
                    {
                        res.push_back(idx);
                    }
                }
            }
        }
    }
    cout<<"最短路径"<<endl;
    for(int i=0;i<res.size();i++)
        cout<<res[i]<<" ";
}
void chart::Reset()
{
    int i=0;
    for(i=0; i<Visited_Mark.size(); i++)
    {
        Visited_Mark[i]=0;
        Parent[i]=-1;
        Distance[i]=INT_MAX;
    }
}
void chart::Dijkstra(int u)
{
    int node=Parent.size();//节点数
    queue<VerNode*> s;

    s.push(VerNode_List[u]);
    Parent[u]=-1;
    Distance[u]=0;

    while(!s.empty())
    {
        int idx=s.front()->Vervex;
        Visited_Mark[idx]=1;
        int last=-1;//记录最后要入队的那个节点的下标
        int last_wt=INT_MAX;
        for(ArcNode*p=VerNode_List[idx]->First_Edge;p!=nullptr;p=p->next)
        {
            int pls=p->Adjvex;
            if(Visited_Mark[pls]==0)//没有被访问过
            {
                if(((p->wet)+Distance[idx])<Distance[pls])
                {
                    Distance[pls]=((p->wet)+Distance[idx]);
                    Parent[pls]=idx;
                }
                if((p->wet)<last_wt)
                {
                    last=pls;
                    last_wt=(p->wet);
                }
            }
        }
        if(last!=-1)//如果最终选中的节点下标等于-1，那么说明没有与当前节点相连的节点了
        {
            s.push(VerNode_List[last]);
        }
        s.pop();
    }
    cout<<endl<<"当前的源节点是"<<u<<endl;
    //打印出各个数组存储的数据

    cout<<"Distance数组："<<endl;
    for(int i=0;i<node;i++)
    {
        cout<<Distance[i]<<" ";
    }
    cout<<endl<<"Parent数组："<<endl;
    for(int i=0;i<node;i++)
    {
        cout<<Parent[i]<<" ";
    }
}
int main()
{
    vector<int>qaq= {0,1,2,3,4,5,6,7,8};
    chart wow;
    wow.make(qaq,14);
    wow.Print();
    wow.BFS(0,4);
    wow.Reset();
    wow.Dijkstra(0);
    return 0;
}

选择测试的无向图：

程序运行：

最后，果然我第一次写的函数在这个无向图翻车了……

具有很强的局限性啊！

建议学习DIjkstra算法和Floyd算法时，看这个视频

https://www.bilibili.com/video/BV1q4411M7r9?from=search&seid=9662298119837732890

思路：

1.使用两个n*n的矩阵Dist，Plain（n是节点的个数），Dist是i节点到j节点的最短距离，Plain存放的是i到j最短路径的节点遍历顺序，

比如Plain[i][j]=k,那么从i到j的最短路径就要经过k节点，那么就去Plain[k][j]查看Plain[k][j]的值是否为j，如果为，那么最短路径就是

i->k->j,否则就继续像之前那样寻找最短路径上的节点。

 

2.初始换Dist数组，其实就是把邻接表转换成邻接矩阵，从而更好操作，主对角线由于图中弧权重可为负数，所以主对角线上可以初始化为一个极大或者极小的值，然后不相通的两个节点的Dist不能直接设置为INT_MAX,在这上面我吃了大亏，他会整型越界,最好设置为INT_MAX-50。

 

3.初始化Plain数组，Plain[i][j]初始化为j，而当i==j的时候，初始化为-1，因为节点中没有-1为下标。

 

4.然后使用三层循环，最外层的k循环，是循环遍历中间节点，内两层循环更新距离数组，如果i先到k这个中间节点在到j节点比之前其他路径更短，那么同时更新路径数组，和顺序数组，很重要的一点在更新的时候，下标为k的行和列以及对角线不参与这种更新。

 

5.最后还有更加重要的一点就是如果i无法到达k的话，就不能更新，因为当k到j的弧的权重为负数的话就会发生非常不好的结果，我深有体会！

 

6.和有向图的一样，可以理解为两个节点之间有两条互相指向的弧且权重相等，不过图中弧如果有负数，会出现一种极其骚的情况就是来回绕！！很迷……所以Floyd可能不适合无向图。

代码：

#include<iostream>
#include<vector>
#include<queue>
#include<climits>
using namespace std;
//边表节点
typedef struct ArcNode
{
    int Adjvex;
    ArcNode*next=nullptr;
    int wet;
    ArcNode(int x,ArcNode*p,int y):Adjvex(x),next(p),wet(y) {}
} ArcNode;
//顶点表节点
typedef struct VerNode
{
    int Vervex;
    ArcNode*First_Edge;
    VerNode(int x,ArcNode*p):Vervex(x),First_Edge(p) {}
} VerNode;
class chart
{
private:
    vector<VerNode*>VerNode_List;//存储图的每一个节点数据
    vector<int>Visited_Mark;//存储访问数据的情况

    vector<int>Parent;//存储节点的上一个父亲节点
    vector<int>Distance;//存储源节点到每一个节点的最短距离
public:
    chart() {}
    void make(vector<int>data,int Road_Nums);
    void Print();
    void BFS(int v,int u);//这是一个对无权最短路径计算不完全的算法，很有局限性
    void Reset();
    void Dijkstra(int u);
    void Floyd();
    ~chart();
};
void chart::make(vector<int>data,int Road_Nums)
{
    VerNode*Node_Pointer_temp;
    ArcNode*Arc_Pointer;
    int i,j,k,w;
    int Data_Len=data.size();
    for(i=0; i<Data_Len; i++)
    {
        Node_Pointer_temp=new VerNode(data[i],nullptr);
        VerNode_List.push_back(Node_Pointer_temp);
        Visited_Mark.push_back(0);
        Parent.push_back(-1);
        Distance.push_back(INT_MAX);
    }
    for(k=0; k<Road_Nums; k++)
    {
        cout<<"请输入无向图的路径i——j，以及权重"<<endl;
        cout<<"请输入i:  ";
        cin>>i;
        cout<<endl<<"请输入j:  ";
        cin>>j;
        cout<<endl<<"请输入i——j之间弧的权重";
        cin>>w;
        cout<<endl;
        Arc_Pointer=new ArcNode(j,VerNode_List[i]->First_Edge,w);
        VerNode_List[i]->First_Edge=Arc_Pointer;
        Arc_Pointer=new ArcNode(i,VerNode_List[j]->First_Edge,w);
        VerNode_List[j]->First_Edge=Arc_Pointer;
    }
}
void chart::Print()
{
    ArcNode*s;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        //cout<<VerNode_List[i]->Vervex;
        s=VerNode_List[i]->First_Edge;
        while(s!=nullptr)
        {
            cout<<" "<<VerNode_List[i]->Vervex<<"——"<<s->Adjvex<<" ";
            s=s->next;
        }
        cout<<endl;
    }
}
chart::~chart()
{
    ArcNode*s;
    ArcNode*q;
    int i;
    for(i=0; i<VerNode_List.size(); i++)
    {
        s=VerNode_List[i]->First_Edge;
        delete VerNode_List[i];
        while(s!=nullptr)
        {
            q=s;
            s=s->next;
            delete q;
        }
    }
}
void chart::BFS(int v,int u)//说实话，这段算法其实很有局限性嗷
{
    int node=VerNode_List.size();

    //第一遍遍历时，存储各个节点到v节点的最短路径长度
    vector<int>first(node);
    //v节点到自身的距离为0
    first[v]=0;

    VerNode*t;//定点表指针
    ArcNode*tu;//边表指针
    int idx;//记录相连节点下标

    queue<VerNode*>op;
    int q_len;//队列长度

    Visited_Mark[v]=1;
    op.push(VerNode_List[v]);

    int floor=0;//记录离源点的最小层数

    while(!op.empty())
    {
        q_len=op.size();
        floor++;
        for(int i=0; i<q_len; i++)
        {
            t=op.front();
            op.pop();
            for(tu=t->First_Edge; tu!=nullptr; tu=tu->next)
            {
                idx=tu->Adjvex;
                if(Visited_Mark[idx]!=1)
                {
                    Visited_Mark[idx]=1;
                    first[idx]=floor;
                    op.push(VerNode_List[idx]);
                }
            }
        }
    }

    //第一次层序遍历没有问题
    cout<<endl<<"我先打印一下最短的路径长度："<<first[u]<<endl;


    //重置节点状态
    Reset();
    floor=0;
    //存储最短路径的数组
    vector<int>res;
    res.push_back(u);
    //再从u开始往回遍历
    Visited_Mark[u]=1;
    op.push(VerNode_List[u]);
     while(!op.empty())
    {
        q_len=op.size();
        floor++;
        for(int i=0; i<q_len; i++)
        {
            t=op.front();
            op.pop();
            for(tu=t->First_Edge; tu!=nullptr; tu=tu->next)
            {
                idx=tu->Adjvex;
                if(Visited_Mark[idx]!=1)
                {
                    Visited_Mark[idx]=1;
                    op.push(VerNode_List[idx]);
                    if((first[u]-floor)==first[idx])
                    {
                        res.push_back(idx);
                    }
                }
            }
        }
    }
    cout<<"最短路径"<<endl;
    for(int i=0;i<res.size();i++)
        cout<<res[i]<<" ";
}
void chart::Reset()
{
    int i=0;
    for(i=0; i<Visited_Mark.size(); i++)
    {
        Visited_Mark[i]=0;
        Parent[i]=-1;
        Distance[i]=INT_MAX;
    }
}
void chart::Dijkstra(int u)
{
    int node=Parent.size();//节点数
    queue<VerNode*> s;

    s.push(VerNode_List[u]);
    Parent[u]=-1;
    Distance[u]=0;

    while(!s.empty())
    {
        int idx=s.front()->Vervex;
        Visited_Mark[idx]=1;
        int last=-1;//记录最后要入队的那个节点的下标
        int last_wt=INT_MAX;
        for(ArcNode*p=VerNode_List[idx]->First_Edge;p!=nullptr;p=p->next)
        {
            int pls=p->Adjvex;
            if(Visited_Mark[pls]==0)//没有被访问过
            {
                if(((p->wet)+Distance[idx])<Distance[pls])
                {
                    Distance[pls]=((p->wet)+Distance[idx]);
                    Parent[pls]=idx;
                }
                if((p->wet)<last_wt)
                {
                    last=pls;
                    last_wt=(p->wet);
                }
            }
        }
        if(last!=-1)//如果最终选中的节点下标等于-1，那么说明没有与当前节点相连的节点了
        {
            s.push(VerNode_List[last]);
        }
        s.pop();
    }
    cout<<endl<<"当前的源节点是"<<u<<endl;
    //打印出各个数组存储的数据

    cout<<"Distance数组："<<endl;
    for(int i=0;i<node;i++)
    {
        cout<<Distance[i]<<" ";
    }
    cout<<endl<<"Parent数组："<<endl;
    for(int i=0;i<node;i++)
    {
        cout<<Parent[i]<<" ";
    }
}
void chart::Floyd()
{
    int node=Parent.size();
    //Floyd算法所需数组
    vector<vector<int>>Dist(node,vector<int>(node,INT_MAX-50));//距离数组
    vector<vector<int>>Plain(node,vector<int>(node));//顺序数组

    //初始化顺序数组
    for(int i=0; i<node; i++)
        for(int j=0; j<node; j++)
        {
            if(i==j)
            {
                Plain[i][j]=-1;
            }
            else
            {
                Plain[i][j]=j;
            }
        }

    /*先打印初始化的顺序数组*/
    cout<<"——初始化的顺序数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
            cout<<Plain[i][j]<<"  ";
        cout<<endl;
    }
    //初始化距离数组
    for(int i=0; i<node; i++)
    {
        int x=VerNode_List[i]->Vervex;
        for(ArcNode*p=VerNode_List[i]->First_Edge; p!=nullptr; p=p->next)
        {
            int y=p->Adjvex;
            Dist[x][y]=p->wet;
        }
    }


    //距离数组对角线
    for(int i=0; i<node; i++)
        for(int j=0; j<node; j++)
        {
            if(i==j)
                Dist[i][j]=0;
        }
    /*打印初始化的距离数组*/
    cout<<"——初始化的距离数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
        {
            if(i==j)
            {
                cout<<"-  ";
                continue;
            }
            if(Dist[i][j]==(INT_MAX-50))//
                cout<<"∞"<<"  ";
            else
                cout<<Dist[i][j]<<"  ";
        }
        cout<<endl;
    }

    //三层循环
    for(int k=0; k<node; k++)
    {
        for(int i=0; i<node; i++)
        {
            if(i==k)
                continue;
            for(int j=0; j<node; j++)
            {
                if(j==k)
                    continue;
                if(i==j)
                    continue;

                /*cout<<"Dist["<<i<<"]["<<k<<"]: ";
                if(Dist[i][k]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[i][k]<<"  ";
                cout<<"Dist["<<k<<"]["<<j<<"]:  ";
                if(Dist[k][j]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[k][j]<<"  ";
                cout<<"Dist["<<i<<"]["<<j<<"]:  ";
                if(Dist[i][j]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[i][j]<<"  ";
                    cout<<endl;*/



                if((Dist[i][k]+Dist[k][j])<Dist[i][j]&&(Dist[i][k]!=(INT_MAX-50)&&Dist[k][j]!=(INT_MAX-50)))//
                {
                    Dist[i][j]=(Dist[i][k]+Dist[k][j]);
                    Plain[i][j]=Plain[i][k];
                }
            }
        }
        cout<<"——中间节点为"<<k<<"之后距离矩阵的更新——"<<endl;
        for(int i=0; i<node; i++)
        {
            for(int j=0; j<node; j++)
            {
                if(i==j)
                {
                    cout<<"-  ";
                    continue;
                }
                if(Dist[i][j]==INT_MAX-50)
                    cout<<"∞"<<"  ";
                else
                    cout<<Dist[i][j]<<"  ";
            }
            cout<<endl;
        }

    }

    //打印距离数组
    cout<<"——距离数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
        {
            if(i==j)
            {
                cout<<"-  ";
                continue;
            }
            if(Dist[i][j]==INT_MAX-50)
                cout<<"∞"<<"  ";
            else
                cout<<Dist[i][j]<<"  ";
        }
        cout<<endl;
    }


    //打印顺序数组
    cout<<"——顺序数组——"<<endl;
    for(int i=0; i<node; i++)
    {
        for(int j=0; j<node; j++)
            cout<<Plain[i][j]<<"  ";
        cout<<endl;
    }
}

int main()
{
    vector<int>qaq= {0,1,2,3,4};
    chart wow;
    wow.make(qaq,9);
    wow.Print();
    wow.BFS(0,4);
    wow.Reset();
    wow.Dijkstra(0);
    wow.Floyd();
    return 0;
}

运行：

 

 

 

秃头的毛睿
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
无向图的最短路径算法JAVA实现
weixin_30323961的博客
04-26 795
一，问题描述 给出一个无向图，指定无向图中某个顶点作为源点。求出图中所有顶点到源点的最短路径。 无向图的最短路径其实是源点到该顶点的最少边的数目。 本文假设图的信息保存在文件中，通过读取文件来构造图。文件内容的格式参考这篇文章第一部分。 二，算法实现思路 无向图的最短路径实现相对于带权的有向图最短路径实现要简单得多。 源点的最短路径距离为0，从源点开始，采用广度优先的顺序，首先将...
图论算法——最短路径算法
tangzhide123yy的博客
04-23 711
求出最短路径的长度 Floyed——Warshall算法 O（n^3） Floyed算法，可以计算图中任意两点之间的最短路径，适用于出现负边权的情况。 算法描述 1.初始化：点u、v如果有边相连，则dis[u][v]=w[u][v]； 如果不相连，则dis[u][v]=0x7fffffff. 2. for(k=1;k<=n;++k) for(i=1;i<=n;++i) for(j...
无向图求最短路径——Dijkstra(迪杰斯特拉算法)
sheriMMM的博客
10-28 1万+
无向图求最短路径——Dijkstra(迪杰斯特拉算法) Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。 问题描述： 如下无向图， 若从顶点1开始计算到其余各顶点的最短路径 首先需要3个辅助数组： dist[] : 记录从顶点1开始到其余各顶点的最短路径 visited[] : 记录该顶点是否被访问过， 初始值设为0 path[] : 记录该顶点最短路径的前驱顶点 求最短路径步骤： ①初始化数组：...
2023-04-08 无向有权图之最短路径问题
lsgwr的博客
04-08 1732
初始化distances[start]=0，其余distance值为+∞对所有的边进行第1次松弛操作,则求出了到所有点经过的边数最多为1的最短路对所有的边进行第2次松弛操作,则求出了到所有点经过的边数最多为2的最短路对所有的边进行第3次松弛操作,则求出了到所有点经过的边数最多为3的最短路对所有的边进行第v-1次松弛操作,则求出了到所有点经过的边数最多为v-1的最短路如果对所有边再进行一次松弛操作，还能更新最小路径的值数组distances，则说明图中包含负权环。
python 无向图最短路径之Dijkstra算法
WYXHAHAHA123的博客
04-29 1万+
无向图： 在数据结构中的无向图通常使用邻接矩阵表示 无向图的邻接矩阵是对称矩阵，有向图的邻接矩阵不是对称矩阵。 共有5个顶点（nodes），7条边（vertices） 其邻接矩阵为：num_node*num_node，矩阵中的数值表示两个相连接的节点的边的权值 节点 A B C D E A 0 6 inf 1 inf ...
无向图-最短路径Dijkstra(迪杰斯特拉算法)算法
csdnjquery163com的博客
11-06 3954
一、算法思路 1、采用广度优先搜索算法； 2、二维数组初始化无向图； 3、创建一个一维数组，初始化起点到其它所有节点的距离为无穷大，起点自己到自己的距离为0； 4、从起点开始找与起点相邻的其它节点的距离，将距离赋值到前面创建的一维数组，将此节点标记为已访问； 5、在一维数组中找一个没有访问过的节点，并且数值是最小的节点，将此节点作为起点重复第4步； 6、直至所有节点全部标记为已访问，程序执行结束； 二、代码 import sys class Graph: #所有节点信息 n
图论最短路算法——spfa算法
ly's Blog
05-14 1265
概述： SPFA–Shortest Path Faster Algorithm 是一种单源最短路算法，通常被认为是Bellman-ford算法的队列优化,在代码形式上接近于BFS，是一个实际中一个非常高效的算法，并且可以解决Dijkstra算法中的所不能解决的负边权，但是如果竞赛中有出题人出数据卡你的spfa，你就难受了，所以这里我建议没有负边权，不要轻易使用spfa算法，而是使用优先队列优化的D...
贪心算法——最短路径算法.rar
05-02
以标题中的“最短路径算法”为例，我们可以联想到著名的Dijkstra算法。Dijkstra算法是由荷兰计算机科学家艾兹格·迪科斯彻提出的，用于寻找图中两点间的最短路径。在有向图或无向图中，该算法能找出从起点到其余所有...
python编写的最短路径算法
01-20
一心想学习算法，很少去真正静下心来去研究，前几天趁着周末去了解了最短路径的资料，用python写了一个最短路径算法。算法是基于带权无向图去寻找两个点之间的最短路径，数据存储用邻接矩阵记录。首先画出一幅无向图...
美国硅谷城镇地图——最短路径问题
03-13
最短路径问题可以被定义为：在带权无向图或有向图中寻找两个特定节点间路径的最小代价。在这个硅谷城镇地图问题中，我们可以假设图是有向的，因为通常交通网络都是单向的。权值可能代表距离、行驶时间或者其它相关的...
算法分析与设计——无向图的应用（C++版）.
05-19
关键字：无向图、最小生成树、Prim算法、Kruskal算法、迷宫问题、最短路径 引言：无向图G=(V, E)由顶点的集合V与边的集合E组成。无向图和有向图的区别在于，构成无向图任意一条边的两个顶点是无序的，就是说，如果(V...
有向最短哈密尔顿路问题的DNA算法
01-01
有向最短哈密尔顿路问题的DNA算法是一份整理发布的食品资料文档，只为你能够轻松获取有向最短...该文档为有向最短哈密尔顿路问题的DNA算法，是一份很不错的参考资料，具有较高参考价值，感兴趣的可以下载看看
最短路径之Dijkstra(迪杰斯特拉)算法（无向图）
热门推荐
长臂人猿的博客
01-08 6万+
简介 Dijkstra(迪杰斯特拉)算法是典型的单源最短路径算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。由for循环可知，其时间复杂度是O（n^2）。 原理 在已知图的邻接矩阵net.vexs[i][j](无向网，含权值的图)的条件下，通过遍历已知图的所有路径，用dis[i]数组来记录到i点...
无向图寻找两点间的最短路径
qq_29848559的博客
10-17 1万+
1.简介 无向图是图结构的一种。本次程序利用邻接表实现无向图，并且通过广度优先遍历找到两点之间的最短路径。 2.广度优先遍历 广度优先遍历(BFS)和深度优先遍历(DFS)是图结构中最常用的遍历方式。其中广度优先遍历配合上队列能够找到两点之间的最短路径，同时也能解决一些其他的问题(比如寻找迷宫的最短逃离路线)。广度优先遍历寻找两点之间最短路径的操作分为以下几步:...
Dijkstra 最短路径算法详解 无向图
ShineRoyal
08-06 2万+
对于最短路径问题，这里介绍一种O(N^2)的求解方法。 对于求最短路径的问题一般都会给出一幅图，或者边与边的关系。如上图。假设我们起点是A，我们要求到F的最短距离，我们会怎么做？ 首先，因为A是起点，所以我们把对于每个点都有个参数，相对于A的距离，默认除了A到A为0，其他都是无穷大。 从起点A开始，我们更新与A相连通的点到A的距离，并把A点标记。如图： 我们遍历一次所有点与A的距
无向图最短路径
最新发布
cml814的博客
04-15 273
给出一个无向图，求起点1到其它所有点的最短距离。 输入格式 第一行输入n, m。n是定点数量，m是边的数量 第2~m+1行，每行三个数u, v, w，分别表示单向边的起点，终点和边的长度。1
简单图论：遍历所有最短路径
不二的博客
11-22 6925
今天遇到了两道要求遍历所有最短路径的题，我一直做不对的原因竟是我把无向图当成了有向图，郁闷的要死。 解决遍历所有最短路径，其实思路很简单，首先通过经典算法[各种算法，求出最短路径的长度，然后就只能DFS来找寻起始点、终点一样，长度为最短路径长度的路径即可，在DFS中可以使用数组来保存路径。 DFS时注意要剪枝，路径上已经走过的点不要重复走，可以用来保存。 这里要注意的是，如果边的权均为正，那...
Leetcode0847. 访问所有节点的最短路径(difficult,BFS,状态压缩)
chenxy_bwave的专栏
04-17 1036
Leetcode0847. 访问所有节点的最短路径(difficult,BFS,状态压缩)，Python题解
图论中最短路径算法详解——Floyd算法
在解决具体问题时，例如BZOJ8171，我们可以利用Floyd算法求解N个节点无向图中从节点S到节点E的最短路权值和，这里的N不超过100，坐标范围为-10000到10000。通过应用Floyd算法，不仅可以得到最短路径的长度，还可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值