动态规划-最短路径问题
动态规划算法难点详解及应用技巧介绍

动态规划算法难点详解及应用技巧介绍动态规划算法(Dynamic Programming)是一种常用的算法思想,主要用于解决具有重叠子问题和最优子结构性质的问题。
在解决一些复杂的问题时,动态规划算法可以将问题分解成若干个子问题,并通过求解子问题的最优解来求解原始问题的最优解。
本文将详细介绍动态规划算法的难点以及应用技巧。
一、动态规划算法的难点1. 难点一:状态的定义在动态规划算法中,首先需要明确问题的状态。
状态是指问题在某一阶段的具体表现形式。
在进行状态定义时,需要考虑到问题的最优子结构性质。
状态的定义直接影响到问题的子问题划分和状态转移方程的建立。
2. 难点二:状态转移方程的建立动态规划算法是基于状态转移的思想,即通过求解子问题的最优解来求解原始问题的最优解。
因此,建立合理的状态转移方程是动态规划算法的关键。
在进行状态转移方程的建立时,需要考虑问题的最优子结构性质和状态之间的关系。
3. 难点三:边界条件的处理在动态规划算法中,边界条件是指问题的最简单情况,用于终止递归过程并给出递归基。
边界条件的处理需要考虑问题的具体要求和实际情况,确保问题能够得到正确的解。
二、动态规划算法的应用技巧1. 应用技巧一:最长递增子序列最长递增子序列是一类经典的动态规划问题。
其求解思路是通过定义状态和建立状态转移方程,找到问题的最优解。
在应用最长递增子序列问题时,可以使用一维数组来存储状态和记录中间结果,通过迭代计算来求解最优解。
2. 应用技巧二:背包问题背包问题是另一类常见的动态规划问题。
其求解思路是通过定义状态和建立状态转移方程,将问题转化为子问题的最优解。
在应用背包问题时,可以使用二维数组来存储状态和记录中间结果,通过迭代计算来求解最优解。
3. 应用技巧三:最短路径问题最短路径问题是动态规划算法的经典应用之一。
其求解思路是通过定义状态和建立状态转移方程,利用动态规划的思想来求解最优解。
在应用最短路径问题时,可以使用二维数组来存储状态和记录中间结果,通过迭代计算来求解最优解。
最短路径经典练习题

最短路径经典练习题一、基础理论题1. 请简述迪杰斯特拉(Dijkstra)算法的基本原理。
2. 什么是贝尔曼福特(BellmanFord)算法?它适用于哪些类型的图?3. 请解释A搜索算法中启发式函数的作用。
4. 如何判断一个图中是否存在负权环?5. 简述弗洛伊德(Floyd)算法的基本步骤。
二、单选题A. 迪杰斯特拉算法B. 贝尔曼福特算法C. 弗洛伊德算法D. A搜索算法A. 初始化距离表B. 选择当前距离最小的顶点C. 更新相邻顶点的距离D. 重复步骤B和C,直到所有顶点都被访问A. 迪杰斯特拉算法B. 贝尔曼福特算法C. 弗洛伊德算法D. A搜索算法A. 启发式函数B. 起始节点C. 目标节点D. 图的规模三、多选题A. 迪杰斯特拉算法B. 贝尔曼福特算法C. 深度优先搜索算法D. 广度优先搜索算法A. 初始化距离矩阵B. 更新距离矩阵C. 查找负权环D. 输出最短路径A. 图的存储结构B. 顶点的数量C. 边的数量D. 起始顶点四、计算题A (3)>B (2)> D\ | ^ \ | | \(2)\ | (1)/C \|(4)A (1)>B (2)> D\ ^ |\(2)\ | (3)/C \ |(1)A (2)>B (3)> D\ | ^\(3)\ | (1)/C \ |(2)五、应用题1. 假设你是一名地图软件的开发者,请简述如何利用最短路径算法为用户提供导航服务。
2. 在一个网络游戏中,玩家需要从起点到达终点,途中会遇到各种障碍。
请设计一种算法,帮助玩家找到最佳路径。
六、判断题1. 迪杰斯特拉算法只能用于无向图的最短路径问题。
()2. 贝尔曼福特算法可以检测图中是否存在负权环。
()3. 在A搜索算法中,如果启发式函数h(n)始终为0,则算法退化为Dijkstra算法。
()4. 弗洛伊德算法的时间复杂度与图中顶点的数量无关。
()七、填空题1. 迪杰斯特拉算法中,用来存储顶点到源点最短距离的数组称为______。
最短路径问题介绍

最短路径问题介绍全文共四篇示例,供读者参考第一篇示例:最短路径问题是指在一个带有边权的图中,寻找连接图中两个特定节点的最短路径的问题。
在实际生活中,最短路径问题广泛应用于交通运输、通信网络、物流配送等领域。
通过解决最短路径问题,可以使得资源的利用更加高效,节约时间和成本,提高运输效率,并且在紧急情况下可以迅速找到应急通道。
最短路径问题属于图论中的基础问题,通常通过图的表示方法可以简单地描述出这样一个问题。
图是由节点和边组成的集合,节点表示不同的位置或者对象,边表示节点之间的连接关系。
在最短路径问题中,每条边都有一个权重或者距离,表示从一个节点到另一个节点移动的代价。
最短路径即是在图中找到一条路径,使得该路径上的边权和最小。
在解决最短路径问题的过程中,存在着多种算法可以应用。
最著名的算法之一是Dijkstra算法,该算法由荷兰计算机科学家Edsger W. Dijkstra于1956年提出。
Dijkstra算法是一种贪心算法,用于解决单源最短路径问题,即从一个给定的起点到图中所有其他节点的最短路径。
该算法通过维护一个距离数组和一个集合来不断更新节点之间的最短距离,直到找到目标节点为止。
除了Dijkstra算法和Floyd-Warshall算法外,还有一些其他与最短路径问题相关的算法和技术。
例如A*算法是一种启发式搜索算法,结合了BFS和Dijkstra算法的特点,对图中的节点进行评估和排序,以加速搜索过程。
Bellman-Ford算法是一种解决含有负权边的最短路径问题的算法,通过多次迭代来找到最短路径。
一些基于图神经网络的深度学习方法也被应用于最短路径问题的解决中,可以获得更快速和精确的路径搜索结果。
在实际应用中,最短路径问题可以通过计算机程序来实现,利用各种算法和数据结构来求解。
利用图的邻接矩阵或者邻接表来表示图的连接关系,再结合Dijkstra或者Floyd-Warshall算法来计算最短路径。
动态规划实现最短路径问题

动态规划实现最短路径问题⼀、设计最短路径的动态规划算法 <算法导论>中⼀般将设计动态规划算法归纳为下⾯⼏个步骤: 1)分析最优解的结构 2)递归定义最优解的值 3)⾃底向上计算最优解的值 4)从计算的最优解的值上⾯构建出最优解⼆、最短路径的结构 从最优解的结构开始分析(我们假设没有权值为负的路径),对于图G<V,E>的所有结点对最短路径的问题,我们能知道⼀条最短路径的⼦路径都是最短路径。
假设⽤邻接矩阵W=w(ij)来表⽰输⼊带权图,考虑从结点i到结点j的⼀条最短路径p,如果p最多有m(m为有限值)条边。
若i=j,则p的权值为0⽽且不包含其他边。
若i ≠ j,可以将i到j的路径转换为i -> k、k->j。
三、⼀个给定的图 1)给定⼀个有向图 2)我们可以给出这个有向图的邻接矩阵四、C++实现1 #include <iostream>2 #include<fstream>3 #include<sstream>4 #include<vector>5 #include<string>6using namespace std;7const int Max_Num = 100;89 typedef struct Point {10int n; //点的个数11double p[Max_Num];12double q[Max_Num];13int root[Max_Num][Max_Num];14double w[Max_Num][Max_Num];15double e[Max_Num][Max_Num];16 }Point;1718 vector<Point> points;19 vector<string> res;20 vector<int> num;2122void file_read();23void createPoint();24void optimalBST();25void printRoot(Point P);26void printOptimalBST(int i, int j, int r, Point P, ofstream &fileWrite);27 template <class Type>28 Type stringToNum(const string& str) {29 istringstream iss(str);30 Type num;31 iss >> num;32 iss.str("");33return num;34 }3536void file_read() {37string str2, str1 = "", result;38 ifstream fileRead("in.dat");39if (fileRead.is_open()) {40while (getline(fileRead, str2, '\n')) {41if (str2.find("") != -1) {42 str1.append(str2 + "");43 }44else {45 num.push_back(stringToNum<int>(str2));46if (str1 != "") {47 res.push_back(str1);48 }49 str1 = "";50 }51 }52 res.push_back(str1);53 fileRead.close();54 }55 }5657void createPoint() {58string temp;59 Point P;60for (int i = 0; i < res.size(); i++) {61 vector<string> temp_str; //存放按照空格分开后的数字62int n = num[i];63 stringstream input(res[i]);64while (input >> temp) {65 temp_str.push_back(temp);66 }67 P.n = n;68for(int k = 0; k<=n; k++) P.p[k] = stringToNum<double>(temp_str[k]);69for(int k = n + 1; k<temp_str.size(); k++) P.q[k-(n+1)] = stringToNum<double>(temp_str[k]);70 points.push_back(P);71 }72 }7374//根据书上的伪代码:接收概率列表p1....pn和q0.....qn以及规模n作为输⼊计算出e和root75void optimalBST(){76 Point P;77for(int i = 0; i<res.size(); i++) {78 vector<string> temp_str; //存放按照空格分开后的数字79int n = num[i];80string temp;81 stringstream input(res[i]);82while (input >> temp) {83 temp_str.push_back(temp);84 }85 P.n = n;8687for(int k = 0; k<=n; k++) P.p[k] = stringToNum<double>(temp_str[k]);88for(int k = n + 1; k<temp_str.size(); k++) P.q[k-(n+1)] = stringToNum<double>(temp_str[k]); 8990//初始化只包括虚拟键的⼦树91for (int i = 1;i <= P.n + 1;++i){92 P.w[i][i-1] = P.q[i-1];93 P.e[i][i-1] = P.q[i-1];94 }95//由下到上,由左到右逐步计算96for (int len = 1;len <= P.n;++len){97for (int i = 1;i <= P.n - len + 1;++i){98int j = i + len - 1;99 P.e[i][j] = Max_Num;100 P.w[i][j] = P.w[i][j-1] + P.p[j] + P.q[j];101//求取最⼩代价的⼦树的根102for (int r = i;r <= j;++r)103 {104double temp = P.e[i][r-1] + P.e[r+1][j] + P.w[i][j];105if (temp < P.e[i][j])106 {107 P.e[i][j] = temp;108 P.root[i][j] = r;109 }110 }111 }112 }113 points.push_back(P);114 }115 }116117void printOptimalBST(int i, int j, int r, Point P, ofstream &fileWrite){118int root_node = P.root[i][j];//⼦树根节点119if (root_node == P.root[1][P.n]){120//输出整棵树的根121 fileWrite << "k" << root_node << "是根" << endl;122 printOptimalBST(i, root_node - 1, root_node, P, fileWrite);123 printOptimalBST(root_node +1 , j, root_node, P, fileWrite);124return;125 }126127if (j < i - 1){128return;129 }else if (j == i - 1){//遇到虚拟键130if (j < r)131 fileWrite << "d" << j << "是" << "k" << r << "的左孩⼦" << endl;132else133 fileWrite << "d" << j << "是" << "k" << r << "的右孩⼦" << endl;134return;135 }136else{//遇到内部结点137if (root_node < r)138 fileWrite << "k" << root_node << "是" << "k" << r << "的左孩⼦" << endl; 139else140 fileWrite << "k" << root_node << "是" << "k" << r << "的右孩⼦" << endl; 141 }142 printOptimalBST(i, root_node - 1, root_node, P, fileWrite);143 printOptimalBST(root_node + 1, j, root_node, P, fileWrite);144 }145146//输出最优⼆叉查找树所有⼦树的根147void printRoot(Point P){148 cout << "各⼦树的根:" << endl;149for (int i = 1;i <= P.n;++i){150for (int j = 1;j <= P.n;++j){151 cout << P.root[i][j] << "";152 }153 cout << endl;154 }155 cout << endl;156 }157158int main(){159 file_read();160 optimalBST();161 ofstream fileWrite("out.dat");162 Point P ;163for(int i = 0; i<points.size(); i++) {164 P = points[i];165 printRoot(P);166 printOptimalBST(1,P.n,-1, P, fileWrite);167 }168 fileWrite.clear();169return0;170 } 上述代码是将给定的邻接矩阵从⽂件中读取 然后根据输⼊的邻接矩阵求出最短路径。
动态规划在最短路径问题中的应用

动态规划在最短路径问题中的应用动态规划是一种解决复杂问题的方法,它将问题分解成更小的子问题,并通过保存子问题的解来避免重复计算,从而提高解决问题的效率。
最短路径问题是在图或者网络中找到从起点到终点的最短路径的问题,可以使用动态规划算法来解决。
本文将介绍动态规划在最短路径问题中的应用及其算法实现。
一、最短路径问题在最短路径问题中,我们需要在图或网络中找到从一个节点到另一个节点的最短路径。
最短路径可以通过边的权重来衡量,权重可以表示距离、时间、代价等。
最短路径问题有多种变体,其中最常见的是单源最短路径和全源最短路径。
单源最短路径问题是在给定一个起点的情况下,找到该起点到其他所有节点的最短路径。
最常用的算法是Dijkstra算法和Bellman-Ford算法。
二、动态规划原理动态规划通过保存子问题的解来避免重复计算,从而提高算法的效率。
它将问题分解成更小的子问题,并使用递推关系来计算子问题的解。
在最短路径问题中,我们可以使用动态规划来计算从起点到每个节点的最短路径。
首先,我们定义一个一维数组dist[]来保存从起点到每个节点的最短路径长度。
初始化时,dist[]的值为无穷大,表示路径长度未知。
然后,我们从起点开始逐步计算每个节点的最短路径长度。
具体的动态规划算法如下:1. 初始化dist[]为无穷大,起点的dist[]为0。
2. 对于每个节点v,按照拓扑顺序进行如下操作:2.1. 对于节点v的所有邻接节点u,如果dist[v] + weight(v, u) < dist[u],则更新dist[u]。
2.2. 拓扑顺序可以根据节点的拓扑顺序进行计算或者使用深度优先搜索(DFS)算法。
三、算法实现下面是使用动态规划算法解决最短路径问题的示例代码:```// 定义图的邻接矩阵和节点个数int graph[MAX][MAX];int numNodes;// 定义dist[]数组来保存最短路径长度int dist[MAX];// 定义拓扑排序和DFS算法需要的变量bool visited[MAX];stack<int> s;// 动态规划算法求解最短路径void shortestPath(int startNode) {// 初始化dist[]数组为无穷大for (int i = 0; i < numNodes; i++) {dist[i] = INT_MAX;}dist[startNode] = 0;// 拓扑排序或DFS计算每个节点的最短路径长度 for (int i = 0; i < numNodes; i++) {if (!visited[i]) {DFS(i);}}// 输出最短路径长度for (int i = 0; i < numNodes; i++) {cout << "Node " << i << ": " << dist[i] << endl; }}// 深度优先搜索void DFS(int node) {visited[node] = true;for (int i = 0; i < numNodes; i++) {if (graph[node][i] != 0 && !visited[i]) {DFS(i);}}s.push(node);}```以上示例代码演示了使用动态规划算法求解最短路径问题的基本原理和步骤。
最短路径问题的动态规划算法

最短路径问题的动态规划算法动态规划是一种解决复杂问题的有效算法。
最短路径问题是指在给定的图中找到从起点到终点路径中距离最短的路径。
本文将介绍动态规划算法在解决最短路径问题中的应用。
1. 最短路径问题简介最短路径问题是图论中的经典问题之一,旨在找到从图中一点到另一点的最短路径。
通常使用距离或权重来衡量路径的长度。
最短路径问题有多种算法可以解决,其中动态规划算法是一种常用且高效的方法。
2. 动态规划算法原理动态规划算法的核心思想是将原问题分解为更小的子问题,并存储已解决子问题的结果,以供后续使用。
通过逐步解决子问题,最终得到原问题的解。
在最短路径问题中,动态规划算法将路径分解为多个子路径,并计算每个子路径的最短距离。
3. 动态规划算法步骤(1)定义状态:将问题转化为一个状态集合,每个状态表示一个子问题。
(2)确定状态转移方程:通过递推或计算得到子问题之间的关系,得到状态转移方程。
(3)确定初始状态:设置与最小子问题相关的初始状态。
(4)递推求解:根据状态转移方程,逐步计算中间状态,直到得到最终解。
(5)回溯路径:根据存储的中间状态,找到最短路径。
4. 动态规划算法示例以经典的Dijkstra算法为例,演示动态规划算法在解决最短路径问题中的应用。
假设有带权重的有向图G,其中节点数为n,边数为m。
算法步骤如下:(1)定义状态:对于图G中的每个节点v,定义状态d[v]代表从起点到节点v的最短距离。
(2)确定状态转移方程:d[v] = min(d[u]+w[u,v]),其中u为节点v 的直接前驱节点,w[u,v]为边(u,v)的权重。
(3)确定初始状态:设置起点s的最短距离d[s]为0,其他节点的最短距离d[v]为无穷大。
(4)递推求解:根据状态转移方程逐步计算中间状态d[v],更新最短距离。
(5)回溯路径:根据存储的前驱节点,从终点t开始回溯,得到最短路径。
5. 动态规划算法的优缺点优点:(1)求解速度快,适用于大规模问题。
动态规划之最短路径源代码

动态规划之最短路径问题源代码#include "stdio.h"#include "conio.h"#define n 16 /*图的顶点数*/#define k 7 /*图的段数*/#define l 30#define MAX 100typedef int NodeNumber;/*节点编号*/typedef int CostType;/*成本值类型*/CostType cost[n][n];NodeNumber path[k];NodeNumber cur=-1;void creategraph(CostType *cost[n][n]) /*创建图的成本矩阵*/ {int i,j,x,y,value;for(i=0;i<n;i++)for(j=0;j<n;j++) cost[i][j]=0;printf("\nEnter the cost of graph:\n");for(i=0;i<l;i++){scanf("%d,%d,%d",&x,&y,&value);cost[x][y]=value;}}void outgraph(CostType *cost[n][n]) /*输出图的成本矩阵*/ {int i,j;printf("Print the cost of graph:\n");for(i=0;i<n;i++){for(j=0;j<n;j++) printf("%2d",cost[i][j]);printf("\n");}}/*使用向前递推算法求多段图的最短路径*/void FPath(CostType *cost[n][n],NodeNumber *path[k]) {int i,j,leng,temp,v[n],d[n];for(i=0;i<n;i++) v[i]=0;for(i=n-2;i>=0;i--){ leng=MAX;for(j=i+1;j<=n-1;j++)if(cost[i][j]>0 && (cost[i][j]+v[j])<leng){leng=cost[i][j]+v[j];temp=j;}v[i]=leng;d[i]=temp;}path[0]=0;path[k-1]=n-1;for(i=1;i<=k-2;i++) path[i]=d[path[i-1]]; }/*输出最短路径序列*/void outpath(NodeNumber *path[k]){int i;printf("\nPrint the shortest treet:\n");for(i=0;i<k;i++) printf("%3d",path[i]); }main(){NodeNumber m,t;creategraph(&cost);outgraph(&cost);FPath(&cost,&path);outpath(&path);}。
动态规划算法有啥用途

动态规划算法有啥用途动态规划算法是一种常用的优化算法,可以在时间和空间上实现高效的计算。
它适用于一系列问题,包括最优化问题、决策问题和计数问题等。
动态规划算法通常用于问题具备「无后效性」(无后效性是指问题的当前状态不会受到未来状态的影响)和「最优子结构」(问题的最优解可以由子问题的最优解推导得到)的情况下。
基本思想是将原问题划分为若干子问题,逐个求解子问题,再根据子问题的最优解推导出原问题的解。
下面将介绍几个典型的应用场景:1. 最短路径问题:最短路径问题是图论中的经典问题,动态规划算法可以高效地解决。
通过构建状态转移方程,可以递推求解从起点到终点的最短路径。
2. 最长公共子序列问题:最长公共子序列问题在字符串处理中非常常见,例如求两个字符串的最长公共子序列长度。
动态规划算法可以通过构建状态转移方程来高效地求解。
3. 背包问题:背包问题是一类经典的组合优化问题,常见的有0-1背包问题、完全背包问题和多重背包问题。
动态规划算法可以用来求解背包问题的最优解。
4. 最大子数组和问题:最大子数组和问题是在一个数列中找到一个连续子数组,使得子数组元素的和最大。
动态规划算法可以用来高效地求解最大子数组和。
5. 最长递增子序列问题:最长递增子序列问题即求解一个序列中最长的子序列,满足子序列中的元素从左到右递增。
动态规划算法可以高效地求解最长递增子序列的长度。
6. 矩阵链乘法问题:矩阵链乘法问题是矩阵计算中常见的优化问题,即给定一系列矩阵,求解它们相乘的最少次数。
动态规划算法可以用来高效地解决该问题。
7. 0-1背包问题:0-1背包问题是指在给定的一组物品中,每个物品可以选择放入背包或不放入背包,目标是使得背包中物品的总价值最大,且背包的容量不能超过一个给定的值。
动态规划算法可以用来求解该问题的最优解。
8. 最大子矩阵和问题:最大子矩阵和问题是在一个二维矩阵中寻找一个子矩阵,使得子矩阵元素的和最大。
动态规划算法可以用来高效地求解最大子矩阵和。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
最短路径问题
下图给出了一个地图,地图中每个顶点代表一个城市,两个城市间的连线代表道路,连线上的数值代表道路长度。
现在,我们想从城市a到达城市E。
怎样走才能使得路径最短,最短路径的长度是多少?设DiS[x]为城市x到城市E的最短路径长度(x表示任意一个城市);
map[i,j]表示i,j两个城市间的距离,若map[i,j]=0,则两个城市不通;
我们可以使用回溯法来计算DiS[x]:
var
S:未访问的城市集合;
function search(who{x}):integer; {求城市who与城市E的最短距离} begin
if Who=E Then Search←0 {找到目标城市}
Else begin
min←maxint;{初始化最短路径为最大}
for i 取遍所有城市 Do
if(map[Who,i]>0{有路})and(i S{未访问})
then begin
S←S-[i];{置访问标志}
j←map[Who,i]+ search(i); {累加城市E至城市Who的路径长度}
S←S+[i]; {回溯后,恢复城市i未访问状态}
if j<min Then min←j; {如果最短则记下}
end;{then}
search←min;{返回最短路径长度}
End;{else}
End;{search}
begin
S←除E外的所有城市;
Dis[a]←search(a);{计算最短路径长度}
输出Dis[a];
end.{main}
这个程序的效率如何呢?我们可以看到,每次除了已经访问过的城市外,其他城市都要访问,所以时间复杂度为O(n!),这是一个“指数级”的算法。
那么,还有没有效率更高的解题方法呢?
首先,我们来观察上述算法。
在求b1到E 的最短路径的时候,先求出从C2到E 的最短路径;而在求从b2刭E 的最短路径的时候,又求了一遍从C2刭E 的最短路径。
也就是说,从C2到E 的最短路径求了两遍。
同样可以发现,在求从Cl 、C2刭E 的最短路径的过程中,从Dl 到E 的最短路径也被求了两遍。
而在整个程序中,从Dl 到E 的最短路径被求了四遍,这是多么大的一个浪费啊!如果在求解的过程中,同时将求得的最短路径的距离“记录在案”,以便将来随时调用,则可以避免这种重复计算。
至此,一个新的思路产生了,即
由后往前依次推出每个Dis 值,直到推出Dis 「a 」为止。
问题是,究竟什么是“由后往前”呢?所谓前后关系是指对于任意一对城市i 和j 来说,如果满足“或者城市i 和城市j 不连通或者dis[i]+map[i ,j]≥dis[j]”的条件,则定义为城市i 在前、城市j 在后。
因为如果城市i 和城市j 连通且Dis[i]+map[i ,j]<Dis 「j 」,则说明城市j 至城市E 的最短路径长度应该比Dis[j]更优。
可城市j 位于城市i 后不可能推出此情况,以至于影响最后的解。
那么,我们应该如何划分先后次序呢?
如上图所示,从城市a 出发,按照与城市a 的路径长度划分阶段。
阶段0包含的出发城市有{a}
阶段1所含的城市有{b1,b2}
阶段2包含的出发城市有{C1,C2,C3,C4}
阶段3包含的出发城市有{D1,D2,D3}
阶段4包含城市{E}
这种划分可以明确每个城市的次序,因为阶段的划分具有如下性质
⑴阶段i 的取值只与阶段i+1有关,阶段i+1的取值只对阶段i 的取值产生影响:
⑵每个阶段的顺序是确定的,不可以调换任两个阶段的顺序;
我们从阶段4的城市E 出发,按照阶段的顺序倒推至阶段0的城市a 。
在求解的各个阶段,利用了k 阶段与k+1阶段之间的如下关系
dis [k][x]=}),(],[][{min 1G y x y x map y dis k y ∈++∈阶段的城市集
dis [4][E]=0
k=4,3…,0,其中dis [k][x]指k 阶段的城市x 。
由此得出程序
dis[E]←0;
for k ←3 downto 0 do {倒序枚举阶段}
for x 取遍k 阶段的所有城市do
begin
dis[x]←∞; {初始化最短路径为最大}
for y取遍k+1阶段的所有城市do if dis[y]+map[x,y]<dis[x] then dis[x]←
dis[y]+map[x,y];{累计消耗,更新最短路径}
end;{for}
输出dis[a];
这个程序的时间复杂度为W(n2),比回溯法的时间复杂度O(n!)要小得多。
总结:此题是动态规划的基础题。
讲解也比较详细。
在求解最短路经问题时,必须对图进行拓扑排序,即划分明确的阶段、状态。