精华内容
下载资源
问答
  • 2022-03-11 16:07:54
    package c2021;
    
    public class zuiduanlujing {
    
    	 int n = 2021;
    	 int cha = 21;
    	 int templist[] = new int[n + 1];
    	 int list[][] = new int[n + 1][n + 1];
    	 boolean flag[] = new boolean[n + 1];
    	 public static void main(String[] args) {
    		zuiduanlujing z = new zuiduanlujing();
    		z.start();
    	}
    	public void start() {
    		for (int i = 1; i <= n; i++) {
    			templist[i] = -1;
    		}
    		templist[1] = 0;
    		for (int i = 1; i <= n; i++) {
    			for (int j = 1; j < i; j++) {
    				if (i - j <= cha) {
    					int zuixiaogongbeishu;
    					for (int k = i; ; k++) {
    						if (k % i == 0 && k % j == 0) {
    							zuixiaogongbeishu = k;
    							break;
    						}
    					}
    					list[i][j] = zuixiaogongbeishu;
    					list[j][i] = zuixiaogongbeishu;
    				}else {
    					list[i][j] = -1;
    					list[j][i] = -1;
    				}
    			}
    			System.out.println(i);
    		}
    		templist[1] = 0;
    		flag[1] = true;
    		jisuan(1);
    		System.out.println(templist[n]);
    	}
    	 
    	 
    	public  void jisuan(int i) {
    		if (i == n) {
    			return;
    		}
    		for (int j = 1; j <= n; j++) {
    			if (list[i][j] != -1) {
    				if (templist[j] != -1) {
    					templist[j] = Math.min(templist[j],templist[i] + list[i][j]);
    				}else {
    					templist[j] = templist[i] + list[i][j];
    				}
    			}
    		}
    		int minindex = 0;
    		for (int j = 1; j <= n; j++) {
    			if (!flag[j] && templist[j] != -1) {
    				minindex = j;
    				break;
    			}
    		}
    		for (int j = 1; j <= n; j++) {
    			if (flag[j]) {
    				continue;
    			}else {
    				if (templist[j] != -1 && templist[j] < templist[minindex]) {
    					minindex = j;
    				}
    			}
    		}
    		flag[minindex] = true;
    		jisuan(minindex);
    	}
    }
    

    更多相关内容
  • 最短路径问题(python实现) 解决最短路径问题:(如下三种算法) (1)迪杰斯特拉算法(Dijkstra算法) (2)弗洛伊德算法(Floyd算法) (3)SPFA算法 第一种算法: Dijkstra算法 广度优先搜索解决赋权有向图或者...
  • 主要介绍了Java实现Dijkstra输出最短路径实例的相关资料,希望通过本文能帮助到大家,需要的朋友可以参考下
  • 最短路径算法实例

    2018-05-17 19:52:59
    一个最短路径算法实例,并包装成文件的输入和输出,需要输入的数据位于in.dat文件,计算结果保存在out.dat文件中
  • 本文实例讲述了Python数据结构与算法之图的最短路径(Dijkstra算法)。分享给大家供大家参考,具体如下: # coding:utf-8 # Dijkstra算法——通过边实现松弛 # 指定一个点到其他各顶点的路径——单源最短路径 # 初始...
  • 本文实例讲述了Python基于Floyd算法求解最短路径距离问题。分享给大家供大家参考,具体如下: Floyd算法和Dijkstra算法,相信大家都不陌生,在最短路径距离的求解中应该算得上是最为基础和经典的两个算法了,今天就...
  • 最短路径问题是 动态规划的一个实例。1.最短路径问题的描述2.举个例子来说明:求从 S 到 T 的最短路径。3.思考方式4.利用动态规划求解问题依次 考虑从 C 到 T 的最短距离。考虑从 B 到 C 的最短距离考虑从 A 到 B 的...

    最短路径问题是 动态规划的一个实例。

    1.最短路径问题的描述

    2.举个例子来说明:

    求从 S 到 T 的最短路径。

    3.思考方式

    4.利用动态规划求解问题

    依次 考虑从 C 到 T 的最短距离。

    考虑从 B 到 C 的最短距离

    考虑从 A  到 B 的最短距离

    考虑从 T 到 A 的最短距离

    每次都是最短距离。

    在整个过程中,我们把 我们的目标问题转化成了一个个的子问题,在子问题 求 最小值,最后解决了这个问题。

    4.子问题的界定

    5.最短路程之间的依赖关系

    每一次计算的时候都是依据前一个子问题。不需要一个一个计算。每次计算都可以直接利用前一个问题的解。

    6.子问题的优化原则

    6.利用动态规划求解是需要条件的,一个反例告诉你,动态规划求解的条件

    分析: 假如从S 到 T 经过的节点依次是 A B C ,从C 到 T ,模10,我们选择 上面的2 . 从 B  到 C,我们的两条路分别是 4 和 7 ,模10,我们选择 上面的 4 ,那么,从B到T的最短距离就是 6; 从 A 到 B ,我们的两条路分别是 6 和 9,模10,我们选择上面的路。

    从 S 到 A ,两条路分别是 8 和 11, 此时 ,模10,我们选择下面的 路。这时,路径就如上图中蓝色的路径了。

    但是,这是最优的路径吗?显然不是,红色的路线才是最优的路径。因为模10后,得到的结果为0,比 1 小。

    为什么是错误的?

    因为 破坏了动态规划的优化原则,它的问题和它的子问题的优化函数之间没有依赖关系。比如,我们考虑最后一段 即 C 到 T的距离,

    显然, 2是最优解,而不是 5 。因此,破坏了优化原则的问题不能使用 动态规划。

    7.动态规划 小结

    可以用于求解组合优化问题。注意 动态规划的 最优化的原则。

    8.代码

    这个问题的简化版本,编码实现:从矩阵的(0,0)位置到矩阵的(array.length-1,array[0].length-1)的位置的最小值。

    展开全文
  • 本文实例讲述了PHP实现的迪科斯彻(Dijkstra)最短路径算法。分享给大家供大家参考,具体如下: 一、待解决问题 单源最短路径问题,在给定有向图中求一个顶点(单源顶点)到其他所有顶点的最短路径问题。在下图中,每...
  • 本文实例讲述了Python使用Dijkstra算法实现求解图中最短路径距离问题。分享给大家供大家参考,具体如下: 这里继续前面一篇《Python基于Floyd算法求解最短路径距离问题》的内容,这里要做的是Dijkstra算法,与Floyd...
  • 本文实例为大家分享了C++求所有顶点之间最短路径的具体代码,供大家参考,具体内容如下 一、思路: 不能出现负权值的边 (1)轮流以每一个顶点为源点,重复执行Dijkstra算法n次,就可以求得每一对顶点之间的最短...
  • 动态规划求解最短路径问题的实例,对比枚举法、逐段累加法、动态规划法的思路以及加法次数

    说明:自己在学习动态规划的过程中,碰到求解最短路径问题的实例,而理解了动态规划之后,再理解实例中的逐段累加法可能会让人难以理解。这篇文章主要是对比枚举法、逐段累加法、动态规划法求解最短路径问题的思路以及加法次数

    问题:两点之间连线上的数字表示距离,求由A到G的最短路径(问题很常见,不过多描述了)

    (图片来源:《运筹学·第三版》清华大学出版社)

    为了说明的方便,这里删去图上的EFG节点,只保留A到D节点

    这里,从A到D一共有2*3*2 = 12条路径,下面是加法运算次数对比:

     

    法一. 普通计算,枚举法
    思路:每条路径是单独计算的,例如:A到B1到C1到D1这条路径,先计算AB1 + B1C1,之后,AB1 + B1C1的和与C1D1相加。

    一共12条路径,每条路径上有2次
    12*2 = 24次
    分别是
    AB1 + B1C1 与 AB1C1长度 + C1D1
    AB1 + B1C1 与 AB1C1长度 + C1D2
    AB1 + B1C2 与 AB1C2长度 + C2D1
    AB1 + B1C2 与 AB1C2长度 + C2D2
    AB1 + B1C3 与 AB1C3长度 + C3D2
    AB1 + B1C3 与 AB1C3长度 + C3D3
    AB2 + B2C2 与 AB2C2长度 + C2D1
    AB2 + B2C2 与 AB2C2长度 + C2D2
    AB2 + B2C3 与 AB2C3长度 + C3D2
    AB2 + B2C3 与 AB2C3长度 + C3D3
    AB2 + B2C4 与 AB2C4长度 + C4D2
    AB2 + B2C4 与 AB2C4长度 + C4D3

     

    法二. 逐段累加法(当理解了动态规划之后,可能会觉得逐段累加不好理解)
    思路:先计算所有的A到C的路径长度,并保存,再计算所有的A到D的路径长度,而A到D的路径中包含了一部分已经计算且保存了的A到C的路径,那么这部分就直接调用保存的结果而无需再次计算(以此类推,如果是ABCDE,先计算所有的A到C的路径长度,再计算所有的A到D的路径长度,再计算所有的A到E的路径长度,这就是逐段累加的含义

    先计算A到C,6条路径,每条路径1次加法,一共6次加法
    AB1 + B1C1
    AB1 + B1C2
    AB1 + B1C3
    AB2 + B2C1
    AB2 + B2C2
    AB2 + B2C3
    并且这六个结果都保存

    再计算A到D,12条路径,每条路径都分为A到C与C到D两部分来看,A到C的路径长度已经计算过且保存了结果,所以对于每条路径来说,只需计算这条路所经过的A到C的路径长度 + 这条路径所经过的CD长度。每条路径都只有1次加法,一共12次加法
    分别是
    AB1C1长度 + C1D1
    AB1C1长度 + C1D2
    AB1C2长度 + C2D1
    AB1C2长度 + C2D2
    AB1C3长度 + C3D2
    AB1C3长度 + C3D3
    AB2C2长度 + C2D1
    AB2C2长度 + C2D2
    AB2C3长度 + C3D2
    AB2C3长度 + C3D3
    AB2C4长度 + C4D2
    AB2C4长度 + C4D3

    6 + 12 = 18次

    可以看出,逐段累加方法相对于枚举法的优势在于,保存所有的逐段累加的计算结果,供之后的计算直接调用

     

    法三. 动态规划法
    思路:逆向寻找最短路径,为了和上面两种方法对比,这里以D为起点,A为终点先计算所有的C到A的路径长度,并保存,而且选出所有的C到A的最短路径长度,再计算所有的D到A的路径长度,而D到A的路径中包含了一部分已经计算、保存且选出的C到A的最短路径,那么这部分就直接调用保存的结果而无需再次计算(以此类推,如果是ABCDE,先计算所有的C到A的路径长度,选出所有的C到A的最短路径长度,再计算所有的D到A的路径长度,选出所有的D到A的最短路径长度,再计算所有的E到A的路径长度)

    先计算C到A,6条路径,每条路径1次加法,一共6次加法
    AB1 + B1C1
    AB1 + B1C2
    AB1 + B1C3
    AB2 + B2C1
    AB2 + B2C2
    AB2 + B2C3
    并且这六个结果都保存,且选出
    C1到A的最短路径长度,AB1C1
    C2到A的最短路径长度,AB1C2
    C3到A的最短路径长度,AB2C3
    C4到A的最短路径长度,AB2C4

    再计算D到A,每条D到A的路径都分为D到C与C到A两部分来看,C到A的路径长度已经计算过且保存了结果,且选出了最短路径,所以不必考虑每条C到A的路径,只用考虑C到A的最短路径,而D到C有8条路径,可以认为当从D到达C时直接选用C到A的最短路径到达A。所以,实际上D到A只需要考虑8条路径,对于这8条路径中的每条路径来说,需要计算的是这条路所经过的DC长度 + C到A的最短路径长度。每条路径都只有1次加法,一共8次加法
    分别是
    AB1C1长度 + C1D1
    AB1C1长度 + C1D2
    AB1C2长度 + C2D1
    AB2C2长度 + C2D2
    AB2C3长度 + C3D2
    AB2C3长度 + C3D3
    AB2C4长度 + C4D2
    AB2C4长度 + C4D3

    6 + 8 = 14次

    可以看出,动态规划相对于逐段累加方法的优势在于,计算D到A的最短路径时,直接取用C到A的最短路径,而不是考虑C到A的全部路径
     

    三种方法结合起来对比

     

    枚举法

    逐段累加法

    动态规划法

    加法次数

    24

    18

    14

    具体加法

    AB1 + B1C1

    AB1 + B1C1

    AB1 + B1C2

    AB1 + B1C2

    AB1 + B1C3

    AB1 + B1C3

    AB2 + B2C2

    AB2 + B2C2

    AB2 + B2C3

    AB2 + B2C3

    AB2 + B2C4

    AB2 + B2C4

    AB1C1长度 + C1D1

    AB1C1长度 + C1D2

    AB1C2长度 + C2D1

    AB1C2长度 + C2D2

    AB1C3长度 + C3D2

    AB1C3长度 + C3D3

    AB2C2长度 + C2D1

    AB2C2长度 + C2D2

    AB2C3长度 + C3D2

    AB2C3长度 + C3D3

    AB2C4长度 + C4D2

    AB2C4长度 + C4D3

    AB1 + B1C1

    AB1 + B1C1(省掉)

    AB1 + B1C2

    AB1 + B1C2(省掉)

    AB1 + B1C3

    AB1 + B1C3(省掉)

    AB2 + B2C2

    AB2 + B2C2(省掉)

    AB2 + B2C3

    AB2 + B2C3(省掉)

    AB2 + B2C4

    AB2 + B2C4(省掉)

    AB1C1长度 + C1D1

    AB1C1长度 + C1D2

    AB1C2长度 + C2D1

    AB1C2长度 + C2D2

    AB1C3长度 + C3D2

    AB1C3长度 + C3D3

    AB2C2长度 + C2D1

    AB2C2长度 + C2D2

    AB2C3长度 + C3D2

    AB2C3长度 + C3D3

    AB2C4长度 + C4D2

    AB2C4长度 + C4D3

    AB1 + B1C1

    AB1 + B1C1(省掉)

    AB1 + B1C2

    AB1 + B1C2(省掉)

    AB1 + B1C3

    AB1 + B1C3(省掉)

    AB2 + B2C2

    AB2 + B2C2(省掉)

    AB2 + B2C3

    AB2 + B2C3(省掉)

    AB2 + B2C4

    AB2 + B2C4(省掉)

    AB1C1长度 + C1D1

    AB1C1长度 + C1D2

    AB1C2长度 + C2D1

    AB1C2长度 + C2D2

    AB1C3长度 + C3D2(省掉)

    AB1C3长度 + C3D3(省掉)

    AB2C2长度 + C2D1(省掉)

    AB2C2长度 + C2D2(省掉)

    AB2C3长度 + C3D2

    AB2C3长度 + C3D3

    AB2C4长度 + C4D2

    AB2C4长度 + C4D3

    展开全文
  • 主要介绍了Java实现利用广度优先遍历(BFS)计算最短路径的方法,实例分析了广度优先遍历算法的原理与使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了基于javascript实现获取最短路径算法代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 本文实例为大家分享了JS实现深度优先搜索求解两点间最短路径的具体代码,供大家参考,具体内容如下 效果: 找出图里点到点最短路径,并打印轨迹 图片如下所示: 代码: const map = [ [0, 1, 1, 0, 1], [1, ...
  • 针对多阶段决策问题,给出了利用最短路径算法的求解思路和实例,即图结点表示状态、弧表示状态之间的先后关系。针对套汇问题,指出了其与一般最短路径问题的本质差异:求解路径上权值乘积的最大值。并基于Floyd算法...
  • 前k条最短路径的算法在国内鲜有研究,本程序以此算法为蓝图,分别采用了Martin(KSP1程序)先生以及Yen先生(KSP2)的算法完成了前k条旅游最短路径的选择。
  • 本文实例为大家分享了C++所有顶点之间最短路径的具体代码,供大家参考,具体内容如下 一、思路: 不能出现负权值的边 用Floyd算法,总的执行时间为O(n的3次方) k从顶点0一直到顶点n-1, 如果,有顶点i到顶点j之间...
  • 最短路径求解算法java实例

    热门讨论 2013-04-22 16:39:18
    最短路径问题是图论研究中的一个经典算法问题,旨在寻找图(由结点和路径组成的)中两结点之间的最短路径。 针对确定起点终点的最短路径问题 - 即已知起点和终点,求两结点之间的最短路径,采用java技术,实现图形...
  • 中文分词技术是中文...基于N-最短路径的分词算法,需要计算有向图中从起点到终点的所有路径值,分词效率低,将动态删除算法与最短路径算法结合,通过从最短路径中删除部分节点的策略减少搜索路径范围,从而提高分词效率。
  • 动态规划求解多段图最短路径

    千次阅读 2021-01-06 22:34:58
    动态规划求解多段图最短路径 题目: 分析见源代码注释 源代码: #include<stdio.h> #define N 10//定义定点数,编号从1开始 #define M 5//定义层数 #define INF 0x3f3f3f int graph[100][100];//图的链接矩阵 ...

    动态规划求解多段图最短路径

    题目:
    在这里插入图片描述
    分析见源代码注释
    源代码:

    #include<stdio.h>
    #define N 10//定义定点数,编号从1开始
    #define M 5//定义层数
    #define INF 0x3f3f3f
    int graph[100][100];//图的链接矩阵
    int num[5] = { 1,4,7,9,10 };//每一层对应的节点最大编号,用于区分每一层
    int cost[N+1];//每一个节点从起点到该节点的最短距离
    int pos[N + 1];//每一个节点对应最短距离的上一节点,用于后续输出最短路径
    void map()
    {
    	int i,x;
    	for (i = 0; i < M-1; i++)//对应每一层,从第二层开始
    	{
    		x = num[i] + 1;
    		while (x <= num[i + 1])//每一层的每个节点
    		{
    			for (int j = 1; j <= 10; j++)//遍历与该节点有链接关系的上一层节点
    			{
    				if (graph[j][x] != 0)
    				{
    					int y = graph[j][x] + cost[j];//该层节点与上一层节点间距离+起点到上一层的最短距离
    					if (y < cost[x])//比较大小,求出起点到该节点的最短距离
    					{
    						cost[x] = y;
    						pos[x] = j;
    					}
    				}
    			}
    			//printf("%d ", cost[x]);//输出每一个节点对应的最短路径代价
    			x++;
    		}
    	}
    }
    void showpath()//输出最短路径
    {
    	int i = N,j=0;
    	int a[M-1];
    	while (i > 1)
    	{
    		a[j++] = pos[i];
    		i = pos[i];
    	}
    	printf("最短路径为:");
    	for (i = M - 2; i >= 0; i--)
    		printf("%d->", a[i]);
    	printf("%d\n",N);
    }
    int main()
    {
    	for (int i = 1; i <= N; i++)
    	{
    		cost[i] = INF;
    		pos[i] = 1;
    	}
    	cost[1] = 0;
    	pos[1] = 0;
    	for (int i = 1; i <= N; i++)
    		for (int j = 0; j <= N; j++)
    			graph[i][j] = 0;
    	graph[1][2] = 4; graph[1][3] = 2; graph[1][4] = 3;//初始化
    	graph[2][5] = 10; graph[2][6] = 9;
    	graph[3][5] = 6; graph[3][6] =7; graph[3][7] =10;
    	graph[4][6] = 3; graph[4][7] =8;
    	graph[5][8] = 4; graph[5][9] = 8;
    	graph[6][8] = 9; graph[6][9] =6;
    	graph[7][8] = 5; graph[7][9] = 4;
    	graph[8][10] = 8; 
    	graph[9][10] = 4;
    	map();
    	showpath();
    	printf("代价为:%d", cost[N]);
    	return 0;
    }
    
    展开全文
  • 主要介绍了Python实现的多叉树寻找最短路径算法,结合实例形式分析了Python使用深度优先查找获取多叉树最短路径相关操作技巧,需要的朋友可以参考下
  • #include //#define LEN sizeof(struct NODE) #define N 10 #define MAX_TYPE 10000 #define ZERO_TYPE 0 /*定义图的邻接链表*/ struct NODE /*邻接表.../*在阶段决策中,各个顶点到收点的最短路径上的前方顶点编号*/
  • C语言数据结构——图的最短路径算法解决实例问题
  • VC 求最短路径算法实例,求两个城市间的最短距离,对研究最短路径路径求值算法的学习有帮助。
  • 本文实例为大家分享了C语言求解无向图顶点之间的所有最短路径的具体代码,供大家参考,具体内容如下 思路一: DFS,遇到终点之后进行记录 辅助存储: std::vector<int> tempPath; std::vector<std>> totalPath; ...
  • 问题描述:用动态规划法求解如图所示多段图中从顶点0到9的最短路径

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,867
精华内容 10,746
关键字:

动态规划最短路径实例