精华内容
下载资源
问答
  • 实验四Floyd 算法 一实验 目的 利用MAT LAB 实现Floyd 算法可对...权值矩阵求出任意两点间的最短距离矩阵和路由矩阵优点是容易理 解可以算出任意两个节点之间最短距离算法且程序容易实现缺 点是复杂度达到不适合计
  • 实验四Floyd 算法 一实验目的 利用MATLAB 实现Floyd 算法可...权值矩阵求出任意两点间的最短距离矩阵和路由矩阵优点是容易理 解可以算出任意两个节点之间最短距离算法且程序容易实现缺 点是复杂度达到不适合计算大量
  • 通信网基础仿真实验 Floyd算法实现计算最短距离矩阵和路由矩阵,查询最短距离和路由 matlab语言
  • 实用标准文案 实验四 Floyd 算法 一实验目的 利用 MATLAB 实现 Floyd 算法可...通过图的权值矩阵 求出任意两点间的最短距离矩阵和路由矩阵 优点是容易理解 可以算出任意两 个节点之间最短距离算法 且程序容易实现 缺
  • java-floyd最短距离算法

    2018-12-10 20:51:02
    java-floyd最短距离算法 public static void main (String[] args){ MatrixDG matrixDG = new MatrixDG(); System.out.println("初始化邻接矩阵"); matrixDG.printMatrix(); System.out.println(&...

    java-floyd最短距离算法

    public static void main (String[] args){
        MatrixDG matrixDG = new MatrixDG();
        System.out.println("初始化邻接矩阵");
        matrixDG.printMatrix();
        System.out.println("运行 floyd 算法");
        matrixDG.floyd();
        System.out.println("最终值");
        matrixDG.printMatrix();
    }
    public static class MatrixDG{
        private char[] mVexs=new char[]{'a','b','c','d'};//顶点集合
        private int[][] mMatrix;//邻接矩阵
        private int mnfinity=99;//表示无穷大
        //创建图,根据已有的数据
        public MatrixDG(){
            //初始化顶点边
            initEdge();
            //初始化边,及距离
            initEdgeSpace();
        }
    
        /**
            * floyd 佛洛伊德
            */
        private void floyd(){
            //输入顶点数和边数
            int n = mVexs.length;//vertex,顶点数
            int [][] e = mMatrix;
                //Floyd-Warshall算法核心语句(设k为中转节点,计算节点i到节点j的距离值)
                for(int k=0;k<n;k++) {
                    for (int i = 0; i < n; i++) {
                        for (int j = 0; j < n; j++) {
                            if (e[i][j] > e[i][k] + e[k][j]) {
                                e[i][j] = e[i][k] + e[k][j];
                            }
                        }
                    }
                }
        }
        private void initEdge(){
            //输入顶点数和边数
            int vlen = mVexs.length;//vertex,顶点数
            int elen = mVexs.length;//edge,边数
            //初始化边
            mMatrix = new int[vlen][elen];
            //初始化,使相同顶点距离为0,到其他订单距离为正无穷
            for(int i=0;i<vlen;i++){
                for(int j=0;j<elen;j++){
                    if(i==j){
                        mMatrix[i][j]=0;
                    }else{
                        mMatrix[i][j]=mnfinity;
                    }
                }
            }
        }
        //初始化,边及距离
        private void initEdgeSpace(){
            edgeSpace('a','b',2);
            edgeSpace('a','c',6);
            edgeSpace('a','d',4);
    
            edgeSpace('b','c',3);
    
            edgeSpace('c','a',7);
            edgeSpace('c','d',1);
    
            edgeSpace('d','a',5);
            edgeSpace('d','c',12);
        }
    
        /**
            *
            * @param e1 边
            * @param e2 边
            * @param space 距离
            */
        private void edgeSpace(char e1,char e2,int space){
            int i= getPosition(e1);
            int j= getPosition(e2);
            mMatrix[i][j]=space;
        }
        //获取字符在数组中的位置
        private int getPosition(char ch){
            for(int i=0;i<mVexs.length;i++){
                if(mVexs[i] == ch)
                    return i;
            }
            return -1;
        }
    
        //打印邻接矩阵
        private void printMatrix(){
            //顶点
            for(int i=0;i<mVexs.length;i++){
                if(i==0) {
                    System.out.print("\t");
                }
                System.out.print(mVexs[i] + "\t");
            }
            System.out.println();
            //顶点的邻接表
            for(int i=0;i<mVexs.length;i++){
                System.out.print(mVexs[i] + "\t");
                for(int j=0;j<mVexs.length;j++) {
                    System.out.print(mMatrix[i][j] + "\t");
                }
                System.out.println();
            }
        }
    }

     

    展开全文
  • 算法思路:先用矩阵e[10][10]存储信息,其中e[i][j]表示i点到j点的距离。若是无法到达则设置为正无穷大。若是e[i][i]则表示e[i][i]=0。 **用void memset(void buffer, int c, int count)对数组进行初始化。其中...

    算法思路:先用矩阵e[10][10]存储信息,其中e[i][j]表示i点到j点的距离。若是无法到达则设置为正无穷大。若是e[i][i]则表示e[i][i]=0。
    用void memset(void buffer, int c, int count)对数组进行初始化。其中buffer是数组,c是每个元素的值,buffer的长度若c=0x3f3f3f3f,则表示正无穷大
    先假设两点路程只经过0号顶点:
    只需要判断e[i][j]>e[i][0]+e[0][j]是否成立,若成立则设置e[i][j]=e[i][0]+e[0][j]
    其他点以此类推。

    代码实现如下:

    #include <iostream>
    using namespace std;
    int main()
    {
    	int e[10][10], n, m, t1, t2, t3;//t1是起点,t2是终点,t3是t1到t2的距离,n是顶点的个数,m是线段的个数
    	memset(e, 0x3f3f3f3f, sizeof(e));//对e中的每个元素进行初始化
    	cin >> n >> m;
    	for (int i = 0; i < n; i++)//设置本身到本身的距离为0
    	{
    		for (int j = 0; j < n; j++)
    		{
    			if (i == j)//设置本身到本身的距离为0
    				e[i][j] = 0;
    		}
    	}
    	for (int i = 0; i < m; i++)//输入数据
    	{
    		cin >> t1 >> t2 >> t3;
    		e[t1][t2] = t3;
    	}
    	for (int i = 0; i < n; i++)//Floyd算法主要内容
    	{							//i代表两点路程只经过i点。
    		for (int j = 0; j < n; j++)
    		{
    			for (int k = 0; k < n; k++)
    			{
    				if (e[j][k] > e[j][i] + e[i][k])//更新两点路程若经过i点时的数据
    					e[j][k] = e[j][i] + e[i][k];
    			}
    		}
    	}
    }
    for(int i=0;i<n;i++)
    {
    	for(int j=0;j<nj++)
    	{
    		cout<<e[i][j];//此时的e中每个元素都是两点之间最短的距离
    	}
    }
    return 0;
    
    展开全文
  • //邻接矩阵 int vexnum,arcnum; //vexnum为图的当前顶点数,arcnum为图的当前边数 }MGraph; ShortPathTable DP[6]={9999,9999,9999,9999,9999,9999}; PathMatrix *P; MGraph *G; //=============初始化栈=======...
  • 给定一个有向邻接图,求从原点出发到任意一点的最短... 采用Dijkstra贪心算法优化版,为了减少建立二维邻接矩阵的空间开销,直接使用顶点的属性。 优化功能:指定任一个顶点为原点,求从原点到其它任意一点的最短距离
  • 求基于Floyd算法的图各顶点间最短距离矩阵 目录求基于Floyd算法的图各顶点间最短距离矩阵1.问题2.解析3.设计4.分析5.源码 1.问题 2.解析 3.设计 4.分析 5.源码 ...

    求基于Floyd算法的图各顶点间最短距离矩阵

    1.问题

    给定一有向图G = <V, E> ,其中V为G的顶点集,E为G的边集,<u, v> 代表从顶点 u 到顶点 v 的有向边,w<u, v> 代表此有向边的权重。(无向图类似,此文不再赘述)

    如何得到有向图中各顶点间的最短距离?

    2.解析

    举个栗子

    给定一有4顶点的有向图G = <V, E> ,顶点和边的对应关系及各边权重如下图所示:
    Floyd
    若要得到点V2到V1的最短距离,从图中不难发现有两种走法:

    1. V2–>V3–>V1 该路径权值为:3+7=10.
    2. V2–>V3–>V4–>V1 该路径权值为:3+1+5=9.

    因此在该图中,我们选择路径2作为V2到V1的最短路径,权值9作为V2到V1的最短距离。

    Floyd算法的核心思想

    a) 初始化:copy<V,E>=G<V,E>.
    不存在的边以极大数表示,矩阵主对角线为0.
    b) For k:=1 to n
    For i:=1 to n
    For j:=1 to n
    If copy[i,j]>copy[i,k]+copy[k,j]
    Then copy[i,j]:=copy[i,k]+copy[k,j];
    c) 算法结束:D即为所有点对的最短路径矩阵

    Floyd算法值得注意的是:若if语句不变,i, j, k三个循环的位置不得随意交换。三者位置不同,算法的意义截然不同,得到的结果矩阵自然也会不同。

    Part 1
    若按i, j, k循环嵌套(最左边是大循环),所得并非最短距离矩阵。因为,先更新的距离(如 copy[2, 1]等)只判断了途经过一个点的最短路径情况,并没有判断途径 0 ~(n-2) 个点的所有情况,所以得到的最短距离不一定准确。而后续以这些并不完全正确的距离为基础而更新的距离,正确性自然不能保证。

    以上图为例,这样写的算法输出的最短路径为路径1,而非实际路径最短的路径2.

    Part 2
    按k, i, j循环嵌套(最左边是大循环),整个矩阵可以达到同步更新的效果。该算法意义是:整个最短距离矩阵同一阶段更新以当前点k为路径中点的最短距离,再进入下一阶段。

    这就避免了Part 1中出现的问题——先更新的距离判断不到图的全部情况,以先更距离为基础的后更距离可能会因前者的不精准而不准确。

    下面看看代码。

    3.设计

    vector<vector<int>> Floyd(vector<vector<int>> mat) {
    
    	//用二维向量存储矩阵
    	vector<vector<int>> copy(N, vector<int>(N));
    	//初始化, 复制矩阵,避免损坏原矩阵
    	copy[u,v]=mat[u,v];
    
    	for (k from 0 to N-1)
    		for (i from 0 to N-1)
    			for (j from 0 to N-1)	
    				//如果i,j两点间的直接距离大于两点经过点k的间接距离,
    				//更新最短距离矩阵copy。
    	return copy; //返回最短距离矩阵
    }
    

    4.分析

    从代码块容易得出,Floyd算法的复杂度为:Floyd()=O(n3).

    5.源码

    https://github.com/KabgRs/F-SDDR/tree/%E7%AE%97%E6%B3%95%E5%88%86%E6%9E%90%E4%B8%8E%E8%AE%BE%E8%AE%A1%E4%BD%9C%E4%B8%9A/03%E6%B1%82%E5%9B%BE%E5%90%84%E7%82%B9%E9%97%B4%E6%9C%80%E7%9F%AD%E8%B7%9D%E7%A6%BB_Floyd%E7%AE%97%E6%B3%95

    展开全文
  • 最短距离之Floyd算法

    2020-03-08 16:39:31
    最短距离问题 用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵(顶点之间的最短距离矩阵)。 算法思想 Floyd算法的核心思想是动态规划。 它将多阶段过程转化为一系列单阶段问题,...

    最短距离问题

    Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵(顶点之间的最短距离矩阵)。

    图1

    算法思想

    Floyd算法可以方便的求得任意两点的最短路径,这称为多源最短路,算法的核心思想是动态规划
    它将多阶段过程转化为一系列单阶段问题,利用各阶段之间的关系,逐个求解。

    根据以往的经验,如果要找到两个顶点直接的最短路程,一般要引入第三个点(如k),即以k为中转点,路线为i->k->j,这样就可以缩短i到j的距离。但是k是1到n的哪一个呢,甚至可能不止有一个中转点,而是经过两个点或者更多点中转会更短,即路线为i->k1->k2->j或者i->k1->k2…->ki>j。


    距离初始图
    各点初始距离图

    假设现在只允许通过1号顶点,即判断以1号为中转点,判断是否产生更短的路径,即判断distmap[i][0]+ distmap[0][j]是否比distmap[i][j]要小

    代码实现为

    for(int i=0;i<n;i++)
    	for(int j=0;j<n;j++)
    		distmap[i][j]=min(distmap[i][j],distmap[i][0]+distmap[0][j]);
    

    .

    min公式
    更新后各点的距离

    可以看出,只通过1号顶点的情况下,distmap[3][2]distmap[4][2]distmap[4][3] 都得到了更新
    接下来我们引入2号顶点,求只允许经过1号和2号两个顶点的情况下的最短路程。
    这时候我们在保留只经过1号顶点的最短距离的情况下,再判断经过2号顶点是否可以产生更短路径。即判断distmap[i][1]+ distmap[1][j]是否比distmap[i][j]要小

    代码实现为:

    for(int i=0;i<n;i++)
    	for(int j=0;j<n;j++)
    		distmap[i][j]=min(distmap[i][j],distmap[i][0]+distmap[0][j]);
    for(int i=0;i<n;i++)
    	for(int j=0;j<n;j++)
    		distmap[i][j]=min(distmap[i][j],distmap[i][1]+distmap[1][j]);
    

    相比于只允许通过1号顶点进行中转的情况下,这里允许通过1和2号顶点进行中转,再次更新了最短距离。同理,以此类推,再允许1,2,3顶点作为中转可再次更新,但我们知道仅仅几次是不能确定最短的,所有总共要通过n次即通过1~n顶点作为中转后,才可以得到最短距离,所以我们可以发现他其实是由前n-1个中转后的状态来推出第n个状态,这也是使得Floyd算法虽然容易理解和编写,但复杂度较大。

    核心伪代码

    void Floyd(){
    	for(中转点从0到n-1遍历)
    		for(起点从0到n-1遍历)
    			for(终点从0到n-1遍历)
    				若经过中转点距离更小则更新距离
    }
    

    算法复杂度分析

    Prim算法的核心就是三重嵌套for循环,所以时间复杂度为O(n³)

    展开全文
  • 基于朴素版Dijkstra短路算法.,将第一步在所有不确定的点中找到离1最短的点进行了优化,利用数据结构堆来优化。 堆优化版Dikstra算法模板 其中,下面的图是用邻接矩阵g来存储,dis[i]表示1点到i点的距离,st[i]...
  • 其实不是原创哈,我写不出来。  如何求图中V0到V5的最短路径呢?... java实现的方式如下:... 第一步,根据图来建立权值矩阵:  int[][] W = {   { 0, 1, 4, -1, -1, -1 },  { 1, 0, 2, 7, 5, -1 },  {
  • Floyd算法求解最短距离 1. 问题 用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵(顶点之间的最短距离矩阵)。 2. 解析 1,从任意一条单边路径开始。所有两点之间的距离是边的权,...
  • 题目大概如下:在一个10*10的矩阵中有两个点A和B,在矩阵中其他的点要么是0,要么是1。如果是1就表示这个点是一个障碍。现在求从A到B的最短距离。 题目其实并不难,但是我在考试的时候所给出的算法还是有问题。我...
  • 用途: 解决单源最短路径问题(已固定一个起点,求它...(2)之后的更新不需要再关心最短距离已确定的点 三种实现模板: 一、矩阵朴素版 二、vector简单版 三、静态邻接表有点复杂版 1 #include <ios...
  • Dijkstra算法可使用的前提:不存在负圈。负圈:负圈又称负环,就是说一个全部由负权的边组成的环,这样的话不存在最...以后不需要再关心1中的“最短距离已确定的顶点”。C++代码:#include using namespace std; #def
  • Floyd算法求有向图两点间最短距离 问题描述 用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵(顶点之间的最短距离矩阵),按实验报告模板编写算法算法描述 在计算两点之间的最短...
  • %当一个点已经求出到原点的最短距离时,其下标i对应的pb(i)赋1 index1=1 %存放存入S集合的顺序 index2=ones(1,length(a)) %存放始点到第i点最短通路中第i顶点前一顶点的序号 d(1:length(a))=inf;d(1)=0 %存放由...
  • 首先自己练习了一下实现dijkstra算法,可以把dj算法与prim算法对比记忆,要理解pre数组、min数组、V标记数组的含义!...//返回到各点最短距离min[]和路径pre[],pre[i]记录s到i路径上i的父结点,pre[s]=-1 //...
  • 文章目录1 Floyed2 Dijkstra 1 Floyed 如下图所示,图中点到点的路径都是单向的,单项箭头线上的数字表示点与点之间的距离。...假设一下,如果AB两点之间的距离是固定的,那么我们怎么让这两点之间的距离,这
  • 任意两点间的最短距离(floyd算法

    千次阅读 2007-11-15 14:35:00
    求最短路径问题的一个O(n^3)算法 优点:容易理解,可以算出任意两个节点之间最短距离算法,程序容易写 缺点:复杂度达到三次方,不适合计算大量数据 Floyd算法的功能是通过一个图的权值矩阵求出它的每两点间的最短...
  • Matlab_图论一些算法

    2013-10-24 23:20:01
    计算有向图的可达矩阵 两点间最短路的Dijkstra算法 关联矩阵和邻接矩阵相互转换 Floyd算法 Kruskal算法 Prim算法 求联通图最短距离矩阵
  • Dijkstra算法可使用的前提:不存在负圈。 负圈:负圈又称负环,就是说一个全部由负权的边组成的环,这样的话不存在最...以后不需要再关心1中的“最短距离已确定的顶点”。 C++代码: #include <bits\stdc+...
  • 用Floyd算法求解下图各个顶点的最短距离,给出距离矩阵(顶点之间的最短距离矩阵) 二、解析 要求得任意两点之间的短路,可以采用松弛操作,对在i和j之间的所有其他点进行一次松弛,即访问从i到j的所有可能路径...
  • “最短路算法”编程项目,指定两个结点,计算最短距离并输出该路径 >题目分析: 1.选择Python语言进行算法编程模拟。 Python语言更加简洁易懂,且用列表的表示自由度更大,内置函数丰富 2.可随机输入任意图表,并...
  • Floyd(佛洛依德,和著名心理心理学家同名)算法用来解决...Floyd基于这样一个事实:如果存在顶点k,使得以k作为中介点是顶点i和顶点j的当前最短距离缩短,则使用顶点k作为顶点i和顶点j的中介点,即当dis[i][k]+dis[k]

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 121
精华内容 48
关键字:

最短距离矩阵算法