精华内容
下载资源
问答
  • floyd算法c++

    2013-10-06 17:28:56
    floyd算法C++代码,可解决最小路径问题
  • Floyd算法C++

    2010-04-12 14:57:02
    Floyd算法求每对结点最短路径。基于C++的类与模板。
  • 算法与数据结构的结课课程的报告。参考文章加自己提炼。求解几个点之间的最短距离的算法c++源码在vs2019可以实现,也比较好容易理解。希望有所帮助。没有要积分,因为我也是参考别人的。
  • 1 Floyd算法 1.1 描述 1.2 实现方法 1.3 算法流程图 1.4 伪代码 1.5 总结 弗洛伊德算法仅有五行,就可以求得任意两个结点之间的最短路径,用一句话概括就是,每执行一次循环就是求从i号结点到j号结点只经过k号...

    1 Floyd算法

    1.1 描述

    在这里插入图片描述

    1.2 实现方法

    在这里插入图片描述

    1.3 算法流程图

    在这里插入图片描述

    1.4 伪代码

    在这里插入图片描述

    1.5 总结

    弗洛伊德算法仅有五行,就可以求得任意两个结点之间的最短路径,用一句话概括就是,每执行一次循环就是求从i号结点到j号结点只经过k号结点的最短路径,蕴含着动态规划的思想。

    2 程序

    2.1 程序流程图

    在这里插入图片描述

    2.2 源码

    #include<iostream>
    #include<iomanip>
    #include<queue>
    #include<vector>
    #include<string>
    using namespace std;
    
    //用邻接矩阵构建有向图
    #define MAX 999//表示无穷
    #define MVNum 20//最大结点数
    typedef int VertexType;//设置结点的数据类型为int型(方便后续修改成char...)
    typedef int ArcType;//设置的权值为int型(方便后续修改成float...)
    
    class Graph//Adjacency Matrix Graph有向图,用邻接矩阵表示
    {
    public:
    	void Create();
    	int LocateVex(VertexType u);//查找Graph中的顶点u,并返回其对应在顶点表中的下标,未找到则返回-1
    	int firstadj(int v);
    	int nextadj(int v, int w);
    	void Floyd();//Floyd算法
    	void print_path();//打印路径
    	void Show();//调试用,打印邻接矩阵
    private:
    	VertexType vexs[MVNum];//顶点表
    	ArcType arcs[MVNum][MVNum];//邻接矩阵
    	ArcType path[MVNum][MVNum];//保存路径
    	int vexnum, arcnum;//图当前的顶点数和边数
    };
    int Graph::LocateVex(VertexType u)
    {//查找Graph中的顶点u,并返回其对应在顶点表中的下标,未找到则返回-1
    	int i;
    	for (i = 0; i < this->vexnum; i++)
    	{
    		if (u == this->vexs[i])
    			return i;
    	}
    	return -1;
    }
    int Graph::firstadj(int v)
    {
    	for (int i = 0; i < this->vexnum; i++)
    	{
    		if (this->arcs[v][i] != MAX)
    			return i;
    	}
    	return -1;
    }
    int Graph::nextadj(int v, int w)
    {
    	for (int i = w + 1; i < this->vexnum; i++)
    	{
    		if (this->arcs[v][i] != MAX)
    			return i;
    	}
    	return -1;
    }
    void Graph::Show()
    {
    	for (int i = 0; i < this->vexnum; i++)
    	{
    		for (int j = 0; j < this->vexnum; j++)
    		{
    			cout << setw(4) << this->arcs[i][j] << " ";
    		}
    		cout << endl;
    	}
    }
    void Graph::Create()
    {
    	cout << "请输入总结点数和总边数:";
    	cin >> this->vexnum >> this->arcnum;//输入总顶点数和总边数
    	cout << "请输入各结点的信息:";
    	for (int i = 0; i < this->vexnum; i++)
    	{
    		cin >> this->vexs[i];
    	}
    	//初始化邻接矩阵
    	for (int i = 0; i < this->vexnum; i++)
    	{
    		for (int j = 0; j < this->vexnum; j++)
    		{
    			this->arcs[i][j] = MAX;
    		}
    	}
    	//构造邻接矩阵
    	for (int i = 0; i < this->arcnum; i++)
    	{
    		int v1, v2, w;
    		cout << "请输入第" << i + 1 << "条边的起点和终点及其对应的权值:";
    		cin >> v1 >> v2 >> w;
    		int m = LocateVex(v1);
    		int n = LocateVex(v2);
    		this->arcs[m][n] = w;
    	}
    	//初始化路径
    	for (int i = 0; i < this->vexnum; i++)
    	{
    		for (int j = 0; j < this->vexnum; j++)
    		{
    			this->path[i][j] = j;矩阵P的初值则为各个边的终点顶点的下标
    		}
    	}
    	return;
    }
    void Graph::Floyd()
    {
    	for (int k = 0; k < this->vexnum; k++)
    		for (int i = 0; i < this->vexnum; i++)
    			for (int j = 0; j < this->vexnum; j++)
    				if (this->arcs[i][k] + this->arcs[k][j] < this->arcs[i][j])
    				{
    					this->arcs[i][j] = this->arcs[i][k] + this->arcs[k][j];
    					this->path[i][j] = this->path[i][k];//path[i][j]=path[i][k]+path[k][j]
    				}
    	cout << "利用Floyd算法所得最短路径长度:" << endl;
    	//更改到自身距离为0
    	for (int i = 0; i < this->vexnum; i++)
    	{
    		for (int j = 0; j < this->vexnum; j++)
    		{
    			if (i == j)
    				this->arcs[i][j] = 0;
    		}
    	}
    	this->Show();
    }
    void Graph::print_path()
    {
    	cout << "各个顶点对的最短路径:" << endl;
    	int row = 0;
    	int col = 0;
    	int temp = 0;
    	for (row = 0; row < this->vexnum; row++) 
    	{
    		for (col = row + 1; col < this->vexnum; col++) 
    		{
    			if (this->arcs[row][col] != MAX)
    			{
    				cout << "v" << to_string(row + 1) << "---" << "v" << to_string(col + 1) << " weight: " << this->arcs[row][col] << " path: " << " v" << to_string(row + 1);
    				temp = path[row][col];
    				//循环输出途径的每条路径。
    				while (temp != col)
    				{
    					cout << "-->" << "v" << to_string(temp + 1);
    					temp = path[temp][col];
    				}
    				cout << "-->" << "v" << to_string(col + 1) << endl;
    			}
    		}
    		cout << endl;
    	}
    }
    int main()
    {
    	Graph s;
    	s.Create();
    	s.Show();
    	s.Floyd();
    	s.print_path();
    	system("pause");
    	return 0;
    }
    

    2.3 测试数据

    在这里插入图片描述

    2.4 运行结果

    在这里插入图片描述

    2.5 参考资料

    1. 《数据结构与算法基础》青岛大学-王卓-网课
    2. 《啊哈!算法》在线阅读 Click Here
    3. 《课堂PPT》
    展开全文
  • C++实现floyd算法

    2013-09-06 14:01:28
    C++实现floyd算法 希望大家指正出现的问题,多多下载,本人需要积分,谢谢大家
  • 弗洛伊德算法(Floyd)

    2018-12-03 09:25:58
    数据结构与算法,图,求每一对顶点间的最短路径问题,弗洛伊德算法完整实现,带注释
  • 图:FLoyd算法

    2014-08-04 13:36:34
    使用Floyd算法,求解点对之间的最短距离。图结构使用邻接矩阵存储。
  • Floyd算法 C++实现

    2019-06-07 17:22:00
    Floyd算法 核心代码: 1 for (k = 0 ;k<n;;k++) 2 for(i=0;i<n;i++) 3 for(j=0;j<n;j++) 4 ...

                                                     Floyd算法

                            核心代码:

     1 for (k = 0 ;k<n;;k++) 
     2        for(i=0;i<n;i++)
     3             for(j=0;j<n;j++)
     4                       if(a[i][k]+a[k][j]<a[i][j])
     5               {
     6                          a[i][j]=a[i][k]+a[k][j];
     7                          path[i][j]=path[k][j];//缩短路径长度,绕过k到j
     8               } 
     9 //a[i][j]是顶点i和j之间的最短路径长度,path[i][j]是相应路径上顶点j的前
    10 //一顶点的顶点号

                                   三重for循环判断,加入一个中间k点,扫描,找到最短路径。时间复杂度O(n^3),主要增加了中间顶点,尝试判断是否小于原来的路径长,如果小于,则以此新路径代替原路径,修改矩阵元素。

                       简单案例:

    在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找最短的从商店到赛场的路线,你可以帮助他们吗?

    输入包括多组数据。每组数据第一行是两个整数N、M(N<=100,M<=10000),N表示成都的大街上有几个路口,标号为1的路口是商店所在地,标号为N的路口是赛场所在地,M则表示在成都有几条路。N=M=0表示输入结束。接下来M行,每行包括3个整数A,B,C(1<=A,B<=N,1<=C<=1000),表示在路口A与路口B之间有一条路,我们的工作人员需要C分钟的时间走过这条路。 输入保证至少存在1条商店到赛场的路线。对于每组输入,输出一行,表示工作人员从商店走到赛场的最短时间

    Sample Input
    2 1

    1 2 3

    3 3

    1 2 5

    2 3 5

    3 1 2

    0 0

    Sample Output
    3 2

     #include<iostream>
     #define maxn 0x3f3f3f3f
     using namespace std;
     int lowcost[1000][1000],i,j,k,n;//全局变量中,变量已全部初始化 
     void floyd()
     {
        for(k=1;k<=n;k++)
            for(i=1;i<=n;i++)
                for(j=1;j<=n;j++)
                     if(lowcost[i][k]+lowcost[k][j]<lowcost[i][j])
                             lowcost[i][j]=lowcost[i][k]+lowcost[k][j];
     }
    int main()
    {
        int m,c,a,b;
        while(cin>>n>>m)//n代表街口数,m代表路数,c代表从a到b之间的分钟数 
        {
            if(n==m&&n==0)
            break;
            for(i=1;i<=n;i++)
               for(j=1;j<=n;j++)
            {  
                if(i==j)lowcost[i][j]=0;//即斜线置0,由a到a权值为0 
                else 
                lowcost[i][j]=maxn;//将数组中的权值置无穷大 
            }
            for(i=1;i<=m;i++)
            {
                cin>>a>>b>>c;//输入路径(即数组下标)a、b及c权值 
                lowcost[a][b]=lowcost[b][a]=c;//将存储路径下标为a、b的数组中置权值为c 
            }
            floyd();//调用floyd算法得到最短路径 
           cout<<lowcost[1][n]<<endl;
        }
        return 0;
    }

     

                                  

    转载于:https://www.cnblogs.com/javabai/p/10988695.html

    展开全文
  • Floyd算法C++极简版)

    千次阅读 2018-06-10 19:26:36
    Floyd算法<伪代码>: 1.初始化权值数组,路径字串 2.依次添加各顶点  2.1判断是否存在经由所添顶点产生的最小路径  2.1.1更新权值数组和路径字串组 源码: #include #include<iomanip>//控制格式 #include #define...

    Floyd算法<伪代码>:

    1.初始化权值数组,路径字串

    2.依次添加各顶点

        2.1判断是否存在经由所添顶点产生的最小路径

            2.1.1更新权值数组和路径字串组

    源码:

    #include<iostream>

    #include<iomanip>//控制格式
    #include<string>


    #define INF 0x3f3f3f3f//定义无穷大
    using namespace std;


    #define vertexNum 5//源点数
    int G[vertexNum][vertexNum];//邻接矩阵
    string vertex[]={"A","B","C","D","E"};//源点字符串组
    void CreateMGraph()
    {
        for(int i=0;i<vertexNum;i++)
            for(int j=0;j<vertexNum;j++)
        {
            if(i==j) G[i][j]=0;
            else G[i][j]=INF;
        }
        G[0][1]=13;G[0][3]=4;
        G[1][0]=13;G[1][2]=15;G[1][4]=5;
        G[2][3]=12;
        G[3][0]=4;G[3][2]=12;
        G[4][2]=6;G[4][3]=3;
    }
    void Floyd()
    {
        int dist[vertexNum][vertexNum],i,k,j;//dist为权值存储数组
        string path[vertexNum][vertexNum];
        //cout<<"初始权值数组和路径字符串数组:"<<endl;
        for(i=0;i<vertexNum;i++)
            for(j=0;j<vertexNum;j++)
        {
            dist[i][j]=G[i][j];
            path[i][j]=vertex[i]+"-->"+vertex[j];
          /*  cout<<path[i][j]<<" ";
            if(dist[i][j]!=INF) cout<<dist[i][j]<<endl;
            else cout<<"∞"<<endl;*/
        }
        for(k=0;k<vertexNum;k++)
             for(i=0;i<vertexNum;i++)
              for(j=0;j<vertexNum;j++)
        {
            if((dist[i][k]+dist[k][j]<dist[i][j])&&(dist[i][k]!=INF)&&(dist[k][j]!=INF)&&(i!=j))
            {
                dist[i][j]=dist[i][k]+dist[k][j];
                path[i][j]=path[i][k]+"-->"+vertex[j];
            }
        }
       for(i=0;i<vertexNum;i++)
       {
           cout<<"顶点"<<vertex[i]<<"到各顶点的最短路径及权值和"<<endl;
              for(j=0;j<vertexNum;j++)
              {
                  cout<<path[i][j]<<" ";
                  if(dist[i][j]!=INF) cout<<dist[i][j]<<endl;
                  else cout<<"∞"<<endl;
              }
       }
    }


    int main()
    {
        CreateMGraph();//创建邻接矩阵
        cout<<"打印邻接矩阵:"<<endl;
         for(int i=0;i<vertexNum;i++)
            for(int j=0;j<vertexNum;j++)
        {
            if(G[i][j]==INF) cout<<setw(4)<<"∞";
            else cout<<setw(4)<<G[i][j];
            if(j==vertexNum-1) cout<<endl;
        }
        Floyd();
        return 0;

    }

    截图:


    展开全文
  • 图的Floyd算法——C/C++

    千次阅读 2019-06-29 22:37:08
    一、算法原理 通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。 从图的带权邻接矩阵A=[a(i,j)],n×n开始,递归地进行n次更新,即由矩阵D(0)=A,按一个公式,构造出矩阵D(1);又用同样地公式由D(1)构造出D...

    例子:
    在这里插入图片描述

    一、算法原理

    1. 通过一个图的权值矩阵求出它的每两点间的最短路径矩阵。
    2. 从图的带权邻接矩阵A=[a(i,j)],n×n开始,递归地进行n次更新,即由矩阵D(0)=A,按一个公式,构造出矩阵D(1);又用同样地公式由D(1)构造出D(2);……;最后又用同样的公式由D(n-1)构造出矩阵D(n)。矩阵D(n)的i行j列元素便是i号顶点到j号顶点的最短路径长度,称D(n)为图的距离矩阵,同时还可引入一个后继节点矩阵path来记录两点间的最短路径。
    3. 采用松弛技术(松弛操作),对在i和j之间的所有其他点进行一次松弛。所以时间复杂度为O(n^3);

    二、算法思想

    1. 从任意一条单边路径开始。所有两点之间的距离是边的权,如果两点之间没有边相连,则权为无穷大。
    2. 对于每一对顶点 u 和v,看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。
    3. 把图用邻接矩阵G表示出来,如果从Vi到Vj有路可达,则G[i][j]=d,d表示该路的长度;否则G[i][j]=无穷大。定义一个矩阵D用来记录所插入点的信息,D[i][j]表示从Vi到Vj需要经过的点,初始化D[i][j]=j。把各个顶点插入图中,比较插点后的距离与原来的距离,G[i][j]= min( G[i][j], G[i][k]+G[k][j] ),如果G[i][j]的值变小,则D[i][j]=k。在G中包含有两点之间最短道路的信息,而在D中则包含了最短通路径的信息。
    4. 比如,要寻找从V5到V1的路径。根据D,假如D(5,1)=3则说明从V5到V1经过V3,路径为{V5,V3,V1},如果D(5,3)=3,说明V5与V3直接相连,如果D(3,1)=1,说明V3与V1直接相连。

    三、算法实现

    1、Floyd算法

    void Floyd(MatGraph MG) {
    	int i, j, k;
    	int A[MAXV][MAXV];
    	int path[MAXV][MAXV];
    	for (i = 0; i < MG.n; i++) {
    		for (j = 0; j < MG.n; j++) {
    			A[i][j] = MG.adjMat[i][j];
    			if (i != j && MG.adjMat[i][j] < INF) {
    				path[i][j] = i;							//顶点 i 到顶点 j 有边时
    			}
    			else {
    				path[i][j] = -1;						//顶点 i 到顶点 j 无边时
    			}
    		}
    	}
    	for (k = 0; k < MG.n; k++) {						//一次考察所有顶点
    		for (i = 0; i < MG.n; i++) {
    			for (j = 0; j < MG.n; j++) {
    				if (A[i][j] > A[i][k] + A[k][j]) {
    					A[i][j] = A[i][k] + A[k][j];		//修改最短路径长度
    					path[i][j] = path[k][j];			//修改最短路径
    				}
    			}
    		}
    	}
    	displayPath(MG, A, path);							//输出最短路径
    }
    

    2、输出多源最短路径

    void displayPath(MatGraph MG, int A[MAXV][MAXV], int path[MAXV][MAXV]) {
    	int i, j, k;
    	int s;
    	int aPath[MAXV];										//存放一条最短路径(逆向)
    	int d;													//顶点个数
    	for (i = 0; i < MG.n; i++) {
    		for (j = 0; j < MG.n; j++) {
    			if (A[i][j] != INF && i != j) {					//若顶点 i 和 顶点 j 之间存在路径
    				printf("从 %d 到 %d 的路径为:", i, j);
    				k = path[i][j];
    				d = 0;
    				aPath[d] = j;								//路径上添加终点
    				while (k != -1 && k != i) {					//路劲上添加中间点
    					d++;
    					aPath[d] = k;
    					k = path[i][k];
    				}
    				d++;
    				aPath[d] = i;								//路径上添加起点
    				printf("%d", aPath[d]);						//输出起点
    				for (s = d - 1; s >= 0; s--) {				//输出路径上其他顶点
    					printf("->%d", aPath[s]);
    				}
    				printf("\t\t");
    				printf("路径长度为:%d\n", A[i][j]);
    			}
    		}
    	}
    }
    

    四、整体框架

    #include<stdio.h>
    #include<malloc.h>
    
    #define MAXV 7					//最大顶点个数 
    #define INF 32767				//定义 ∞
    //∞ == 32767 ,int 型的最大范围(2位)= 2^(2*8-1),TC告诉我们int占用2个字节,而VC和LGCC告诉我们int占用4个字节
    //图:Graph
    //顶点:Vertex
    //邻接:Adjacency
    //矩阵:Matrix
    //表:List
    //边:Edge 
    
    typedef struct vertex {
    	int number;					//顶点的编号 	
    }VertexType; 					//别名,顶点的类型 
    
    typedef struct matrix {
    	int n;						//顶点个数
    	int e;						//边数 
    	int adjMat[MAXV][MAXV];		//邻接矩阵数组			
    	VertexType ver[MAXV];		//存放顶点信息 
    }MatGraph;						//别名,完整的图邻接矩阵类型
    
    typedef struct eNode {
    	int adjVer;					//该边的邻接点编号 
    	int weiLGht;				//该边的的信息,如权值 
    	struct eNode* nextEdLGe;	//指向下一条边的指针 
    }EdgeNode; 						//别名,边结点的类型 
    
    typedef struct vNode {
    	EdgeNode* firstEdLGe;		//指向第一个边结点 
    }VNode; 						//别名,邻接表的头结点类型 
    
    typedef struct list {
    	int n;						//顶点个数
    	int e;						//边数
    	VNode adjList[MAXV];		//邻接表的头结点数组 
    }ListGraph;						//别名,完整的图邻接表类型 
    
    //创建图的邻接表 
    void createAdjListGraph(ListGraph*& LG, int A[MAXV][MAXV], int n, int e) {
    	int i, j;
    	EdgeNode* p;
    	LG = (ListGraph*)malloc(sizeof(ListGraph));
    	for (i = 0; i < n; i++) {
    		LG->adjList[i].firstEdLGe = NULL;						//给邻接表中所有头结点指针域置初值 
    	}
    	for (i = 0; i < n; i++) {									//检查邻接矩阵中的每个元素 
    		for (j = n - 1; j >= 0; j--) {
    			if (A[i][j] != 0) {									//存在一条边 
    				p = (EdgeNode*)malloc(sizeof(EdgeNode));		//申请一个结点内存
    				p->adjVer = j;									//存放邻接点 
    				p->weiLGht = A[i][j];							//存放权值
    				p->nextEdLGe = NULL;
    
    				p->nextEdLGe = LG->adjList[i].firstEdLGe;		//头插法 
    				LG->adjList[i].firstEdLGe = p;
    			}
    		}
    	}
    	LG->n = n;
    	LG->e = e;
    }
    
    //输出邻接表 
    void displayAdjList(ListGraph* LG) {
    	int i;
    	EdgeNode* p;
    	for (i = 0; i < MAXV; i++) {
    		p = LG->adjList[i].firstEdLGe;
    		printf("%d:", i);
    		while (p != NULL) {
    			if (p->weiLGht != 32767) {
    				printf("%2d[%d]->", p->adjVer, p->weiLGht);
    			}
    			p = p->nextEdLGe;
    		}
    		printf(" NULL\n");
    	}
    }
    
    //输出邻接矩阵
    void displayAdjMat(MatGraph MG) {
    	int i, j;
    	for (i = 0; i < MAXV; i++) {
    		for (j = 0; j < MAXV; j++) {
    			if (MG.adjMat[i][j] == 0) {
    				printf("%4s", "0");
    			}
    			else if (MG.adjMat[i][j] == 32767) {
    				printf("%4s", "∞");
    			}
    			else {
    				printf("%4d", MG.adjMat[i][j]);
    			}
    		}
    		printf("\n");
    	}
    }
    
    //邻接表转换为邻接矩阵
    void ListToMat(ListGraph* LG, MatGraph& MG) {
    	int i, j;
    	EdgeNode* p;
    	for (i = 0; i < MAXV; i++) {
    		for (j = 0; j < MAXV; j++) {
    			MG.adjMat[i][j] = 0;
    		}
    	}
    	for (i = 0; i < LG->n; i++) {
    		p = LG->adjList[i].firstEdLGe;
    		while (p != NULL) {
    			MG.adjMat[i][p->adjVer] = p->weiLGht;
    			p = p->nextEdLGe;
    		}
    	}
    	MG.n = LG->n;
    	MG.e = LG->e;
    }
    
    //输出多源最短路径
    void displayPath(MatGraph MG, int A[MAXV][MAXV], int path[MAXV][MAXV]) {
    	int i, j, k;
    	int s;
    	int aPath[MAXV];										//存放一条最短路径(逆向)
    	int d;													//顶点个数
    	for (i = 0; i < MG.n; i++) {
    		for (j = 0; j < MG.n; j++) {
    			if (A[i][j] != INF && i != j) {					//若顶点 i 和 顶点 j 之间存在路径
    				printf("从 %d 到 %d 的路径为:", i, j);
    				k = path[i][j];
    				d = 0;
    				aPath[d] = j;								//路径上添加终点
    				while (k != -1 && k != i) {					//路劲上添加中间点
    					d++;
    					aPath[d] = k;
    					k = path[i][k];
    				}
    				d++;
    				aPath[d] = i;								//路径上添加起点
    				printf("%d", aPath[d]);						//输出起点
    				for (s = d - 1; s >= 0; s--) {				//输出路径上其他顶点
    					printf("->%d", aPath[s]);
    				}
    				printf("\t\t");
    				printf("路径长度为:%d\n", A[i][j]);
    			}
    		}
    	}
    }
    
    //Floyd算法
    void Floyd(MatGraph MG) {
    	int i, j, k;
    	int A[MAXV][MAXV];
    	int path[MAXV][MAXV];
    	for (i = 0; i < MG.n; i++) {
    		for (j = 0; j < MG.n; j++) {
    			A[i][j] = MG.adjMat[i][j];
    			if (i != j && MG.adjMat[i][j] < INF) {
    				path[i][j] = i;							//顶点 i 到顶点 j 有边时
    			}
    			else {
    				path[i][j] = -1;						//顶点 i 到顶点 j 无边时
    			}
    		}
    	}
    	for (k = 0; k < MG.n; k++) {						//一次考察所有顶点
    		for (i = 0; i < MG.n; i++) {
    			for (j = 0; j < MG.n; j++) {
    				if (A[i][j] > A[i][k] + A[k][j]) {
    					A[i][j] = A[i][k] + A[k][j];		//修改最短路径长度
    					path[i][j] = path[k][j];			//修改最短路径
    				}
    			}
    		}
    	}
    	displayPath(MG, A, path);							//输出最短路径
    }
    
    int main() {
    	ListGraph* LG;
    	MatGraph MG;
    
    	int array[MAXV][MAXV] = {
    		{  0,  4,  6,  6,INF,INF,INF},
    		{INF,  0,  1,INF,  7,INF,INF},
    		{INF,INF,  0,INF,  6,  4,INF},
    		{INF,INF,  2,  0,INF,  5,INF},
    		{INF,INF,INF,INF,  0,INF,  6},
    		{INF,INF,INF,INF,  1,  0,  8},
    		{INF,INF,INF,INF,INF,INF,  0}
    	};
    
    	int e = 12;
    	createAdjListGraph(LG, array, MAXV, e);
    	displayAdjList(LG);
    	printf("\n");
    
    	ListToMat(LG, MG);
    	displayAdjMat(MG);
    	printf("\n");
    
    	Floyd(MG);
    	printf("\n");
    
    	return 0;
    }
    

    五、结果展示

    在这里插入图片描述

    展开全文
  • 最短路径问题 问题描述:平面上有n个点(n),每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线,则表示可从一个点到达另一个点,即两点间有... } 输出示例 补充参考 C++优先队列自定义排序总结
  • 最完整+全解析的Floyd算法(C++版)

    千次阅读 2021-02-17 21:58:08
    全网最完整、最易懂的Floyd算法(弗洛伊德算法),邻接矩阵实现的C++版,多注释、配合视频讲解更易懂!
  • 最短路径算法 Dijkstra算法与Floyd算法C++实现)

    万次阅读 多人点赞 2018-09-09 21:44:20
    最短路径算法 Dijkstra算法与Floyd算法C++实现) Dijkstra算法又称为单源最短路径,所谓单源是在一个有向图中,从一个顶点出发,求该顶点至所有可到达顶点的最短路径问题。 Floyd算法是解决任意两点间的最短路径...
  • Floyd算法建立在对图的邻接矩阵的操作上,理解Floyd首先要理解邻接矩阵 对于有向图,邻接矩阵的一行代表该顶点的出边,一列代表该顶点的入边 对于无向图则不区分出边与入边,邻接矩阵表示成一个对称矩阵 graph...
  • 弗洛伊德算法其实是一种非常简单的图论算法,总的来说,弗洛伊德算法甚至可以说是一种暴力枚举。 弗洛伊德算法是解决任意两点间的最短路径的一种算法,可以正确处理有向图或负权(但不可存在负权回路)的最短路径...
  • Floyd算法C++代码

    2021-09-11 16:34:28
    //无向有权图的最短路径算法——Floyd(弗洛伊德)算法 //时间复杂度为O(n*n*n) //空间复杂度为T(n*n) #include<bits/stdc++.h> #define N 10000001 using namespace std; int ma[101][101],n,g,s,t;//节点数...
  • Floyd-Warshall算法,简称Floyd算法 该算法用于求解任意两点间的最短距离,时间复杂度为O(n^3)。 通常可以在任何图中使用,包括有向图、带负权边的图。 Floyd算法求得两点间的最短距离,需要借助邻接矩阵来存储边...
  • Floyd算法算是最简单的算法,没有之一。 其状态转移方程如下map[i , j] =min{ map[i , k] + map[k , j] , map[i , j] }; map[i , j]表示 i 到 j 的最短距离,K是穷举 i , j 的断点,map[n , n]初值应该为0,或者...
  • 弗洛伊德Floyd算法: 也称插点法,该算法用来求解每一对顶点之间的最短路径 假设从顶点1到2,顶点3为过度中间顶点则: 如果某个顶点位于从起点到终点的最短路径上: 1->2=(1->3)+(3->2) 如果某个顶点不...
  • #include <iostream> #include <vector> #include <algorithm> #include <limits> #include <iomanip> using namespace std; const int INF = INT_MAX...void Floyd(int n, vector&l...
  • C++ Floyd算法

    千次阅读 2017-05-23 14:10:13
    Dijkstra算法用于一个点到图中任意一点的最短路径,Floyd算法用于连通图中任意点到任意点的最短路径。Floyd从算法来看就很简单暴力,时间复杂度O(n^3),中心思想就是比如0-2不经过任何中转点是没有路径的,那么假如...
  • Floyd算法求解最短路径问题(C++实现)(源码见链接) Floyd(弗洛伊德)算法也可称其为插点算法,是一种基于动态规划思想的最短路径算法。动态规划算法将求解的分体分成若干个阶段,按顺序求解子阶段并且动态规划算法...
  • Floyd算法 C++

    2016-07-16 11:26:49
    【问题描述】 给出N个顶点,M条无向带权边的连通图,和Q个查询:请编程回答:  问1、两点之间的最短路径(边权和最小的路径);  问2、两点之间的所有路径中,需要经过的最小边的最大的路径(最大边最小);...
  • C++实现一个简单的Floyd算法

    千次阅读 2021-04-25 09:34:37
    void Floyd(Graph<EdgeType>&G,EdgeType **Adj,int **Path) { int i,j,v;//i,j为计数器,v记录相应顶点 int n=G.VerticesNum(); for(i=0;i<n;i++)//初始化D数组,Path数组 { for(j=0;j<n;j++)...
  • 最短路径---Floyd算法C++

    千次阅读 2018-12-05 20:32:31
    Floyd算法的介绍 算法的特点:  弗洛伊德算法是解决任意两点间的最短路径的一种算法,可以正确处理有向图或有向图或负权(但不可存在负权回路)的最短路径问题,同时也被用于计算有向图的传递闭包。 算法的思路 ...
  • 最短路径问题—Dijkstra算法和Floyd算法C++) 最短路径:任两顶点之间经历的边数最少的路径。 非带权图——边数最少的路径 带权图——边上的权值之和最少的路径 Dijkstra算法【广度优先遍历】 解决的是单源点到...
  • 方法2:可以采用Floyd算法,它是一种用来求双源点之间最短路径的算法,采用邻接矩阵来存储图 辅助结构 int D[maxSize][maxSize];//表示从各个顶点之间最短路径长度 例:D[i][j]:表示从i顶点到j顶点的最短路径长度 ...
  • 文章目录数据结构C++——最短路径之Dijkstra算法和Floyd算法一、最短路径之Dijkstra算法①Dijkstra算法的实现原理②Dijkstra算法的代码实现③测试的完整代码二、最短路径之Floyd算法Floyd算法的实现原理②Floyd...
  • Floyd算法——C++实现版

    千次阅读 2015-11-16 16:40:51
    // Floyd.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #define MAX_VALUE 1000 #define MAX_VERTEX_COUNT 20 using namespace std; struct MGraph { int *edges[MAX_VALUE];...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,579
精华内容 2,231
关键字:

floyd算法c++

c++ 订阅
友情链接: LAN.rar