多段图最短路径_动态规划

合集下载

动态规划求最短路径的两种方法

动态规划求最短路径的两种方法

动态规划1.最短路线问题解(1):将上图该画成下图:记a (1,2)=4,a(1,3)=5,依次类推,表示每个点和值的关系。

逆序递推方程:⎪⎩⎪⎨⎧==+++=0)6(61,2,3,4,5)}1(1),({min )(s f k k s k f k u k s k d k uk s k fAB 1B 2C 1 C 2C 3 C 4D 1D 2 D 3E 1 E 2F4523 6 8 7 75845348435 6 2 314 31234 5 6 789 101112134523 6 8 7 7584534 8435 6 2 314 3如图各状态:逆序递推,找出上一个状态到下一阶段的最小路径值。

例如,当K=4时,状态 它们到F 点需经过中途 点E ,需一一分析从E 到 F 的最短路:先说从D1到F 的最短路 有两种选择:经过 E1, E2, 比较最短。

这说明由 D1 到F 的最短距离为7,其路径为AB 1B 2C 1 C 2C 3 C 4D 1 D 2 D 3E 1 E 2F4523 6 87 75845348435 62 31 4 3第1阶段 第2阶段 第3阶段 第4阶段 第5阶段状态 1状态 2状态3状态 4状态 5状态 6)}(),(),(),(m in{)(252141511414E f E D d E f E D d D f ++=.7}35,43min{=++=.11F E D →→},,{3214D D D S =a=[0,4,5,inf,inf,inf,inf,inf,inf,inf,inf,inf,inf 4,0,inf,2,3,6,inf,inf,inf,inf,inf,inf,inf 5,inf,0,inf,8,7,7,inf,inf,inf,inf,inf,inf inf,2,inf,0,inf,inf,inf,5,8,inf,inf,inf,inf inf,3,8,inf,0,inf,inf,4,5,inf,inf,inf,inf inf,6,7,inf,inf,0,inf,inf,3,4,inf,inf,inf inf,inf,7,inf,inf,inf,0,inf,8,4,inf,inf,inf inf,inf,5,4,inf,inf,inf,0,inf,inf,3,5,inf inf,inf,inf,8,5,3,8,inf,0,inf,6,2,inf inf,inf,inf,inf,inf,4,4,inf,inf,0,1,3,inf inf,inf,inf,inf,inf,inf,inf,3,6,1,0,inf,4 inf,inf,inf,inf,inf,inf,inf,5,2,3,inf,0,3 inf,inf,inf,inf,inf,inf,inf,inf,inf,inf,4,3,0]; s8=min(a(8,11)+a(11,13),a(8,12)+a(12,13)); s9=min(a(9,11)+a(11,13),a(9,12)+a(12,13)); s10=min(a(10,11)+a(11,13),a(10,12)+a(12,13)); s4=min(a(4,8)+s8,a(4,9)+s9); s5=min(a(5,8)+s8,a(5,9)+s9); s6=min(a(6,9)+s9,a(6,10)+s10); s7=min(a(7,9)+s9,a(7,10)+s10); s2=[a(2,4)+s4,a(2,5)+s5,a(2,6)+s6]; s2=min(s2);s3=[a(3,5)+s5,a(3,6)+s6,a(3,7)+s7]; s3=min(s3);s1=min(a(1,2)+s2,a(1,3)+s3)运行结果为:s8 = 7 s9 = 5 s10 = 5 s4 = 12 s5 = 10 s6 = 8 s7 = 9 s2 =13s3 = 15 s1 = 17结果分析:s 表示每个点到终点的最短距离,那么最短路程为17。

动态规划_多段图_最小花费通路算法_C语言

动态规划_多段图_最小花费通路算法_C语言

动态规划_多段图_最小花费通路算法_C语言动态规划找出多段图的最小花费通路算法(C语言)//算法:#include#include#define MAX 50#define MAX_LEN 100 /*定义顶点之间最大花费(假设最大花费为100)*///结构体定义typedef struct edgenode{ /*定义边表结点结构体*/int adjvertex; /*邻接点编号*/int len; /*该结点与父结点之间的花费*/struct edgenode *next; /*指向下一个邻接点*/} EdgeNode;typedef struct vertexnode{ /*定义顶点结点结构体*/EdgeNode *firstedge; /*边表头指针*/} VertexNode;typedef struct { /*定义邻接表结构体*/VertexNode adjlist[MAX]; /*邻接表*/int vertexNum; /*顶点数*/int edgeNum; /*边数*/} ALGraph;//函数声明ALGraph * CreateALGraph(int vertexNum, int edgeNum);void MultistageGraph(ALGraph *G, int n, int route[], int *minCost);//主函数int main(){ALGraph *G = NULL;int vertexNum, edgeNum; /*顶点数和边数*/int *route; /*从源点到收点的最短路径上的顶点编号*/int minCost; /*最短路径的最小费用*/int i;printf("请输入顶点数和边数:\n");scanf("%d,%d", &vertexNum,&edgeNum);//初始化GG = CreateALGraph(vertexNum, edgeNum);if(!G){return 0;}//初始化route数组route = (int *)malloc(sizeof(int) * vertexNum);MultistageGraph(G, vertexNum, route, &minCost);//输出最小花费路径及最小花费printf("\n最小花费路径是:\n");for(i = 0; i < vertexNum; i ++){printf("%d —> ", route[i]);if(route[i] == (vertexNum - 1)){printf("\b\b\b\b \n");break;}}printf("\n最小花费是:%d\n", minCost);return 0;}/*********************************************************** 函数名称:GreateALGraph函数功能:初始化有向图的邻接表输入:顶点数ertexNum,边数edgeNum输出:指向已初始化完毕的有向图的邻接表指针***********************************************************/ ALGraph * CreateALGraph(int vertexNum, int edgeNum){ ALGraph *G = NULL;int i, j, u, v, info;G = (ALGraph *)malloc(sizeof(ALGraph));if(G){G->vertexNum = vertexNum;G->edgeNum = edgeNum;for(i = 0; i < vertexNum; i ++) {G->adjlist[i].firstedge = NULL;}//给边表结点分配内存空间printf("请输入分段图中各相邻结点的编号及其权值:\n");for(j = 0; j < edgeNum; j ++) {//初始化边结点EdgeNode *pnode = NULL;pnode = (EdgeNode *)malloc(sizeof(EdgeNode));pnode->next = NULL;//输入相邻结点的编号及其边上的权值scanf("%d,%d,%d", &u, &v, &info);if(pnode){pnode->next = G->adjlist[u].firstedge;G->adjlist[u].firstedge = pnode;pnode->adjvertex = v;pnode->len = info;}else{return NULL;}}}return G;}/***********************************************************函数名称:MultistageGraph函数功能:多段图中利用动态规划找出源点到收点的最小花费通路输入:指向有向图的邻接表指针G,结点个数n,保存最小花费通路结点的数组route,保存最小花费minCost输出:最小花费通路结点的数组route,最小花费minCost***********************************************************/void MultistageGraph(ALGraph *G, int n, int route[], int *minCost){int *cost; /*每个结点到收点的最小费用*/int *path; /*在阶段决策中,各个顶点到收点的最短路径上的前方顶点编号*/int i;//给cost、path、route指针分配n个int大小的内存空间cost = (int *)malloc(sizeof(int) * n);path = (int *)malloc(sizeof(int) * n);//初始化cost、path、route指向的内存空间for(i = 0; i < n; i ++) {cost[i] = MAX_LEN;path[i] = -1;route[i] = 0;}cost[n-1] = 0; /*收点到收点的距离为0*///动态规划过程for(i = i - 2; i >= 0; i --) {EdgeNode *pnode = G->adjlist[i].firstedge;while(pnode && (pnode->len + cost[pnode->adjvertex]) < cost[i]) { cost[i] = pnode->len + cost[pnode->adjvertex];path[i] = pnode->adjvertex;pnode = pnode->next;}}i = 0;while((route[i] != n-1) && (path[i] != -1)) {i ++;route[i] = path[route[i - 1]];}//最小花费*minCost = cost[0];//释放malloc申请的内存空间free(cost);free(path);return;}运行结果:。

动态规划------最短路径问题

动态规划------最短路径问题

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

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)的位置的最⼩值。

例:动态规划解最短路径问题:

例:动态规划解最短路径问题:

● 例:动态规划解最短路径问题:步骤(1)、(2)已实现。

最优子结构:从起点到终点的最短路径包含了该路径上各点到终点的最短路径。

递归公式:设v 为图中一个顶点,v 1, v 2,…, v m 为v 的直接后继,cost(v)表示v 到终点的最短路径长度,c[u, w]表示边<u,w>上的权,t 为终点,则cost 满足如下递归公式:⎪⎪⎩⎪⎪⎨⎧≠∞=≠+=≤≤无后继且有后继且v t v , tv , 0v t v , )}cost(v ] v {c[v,min cost(v)i i m i 1步骤(3) 计算最优值(求最短路径长度):设有向网G含n个顶点,用邻接矩阵c[1..n, 1..n]表示,起点为s,终点为t 。

有关信息的保存:数组cost[1..n]: 存储子问题的解。

(cost[i]表示从顶点i到终点t的最短路径长度。

)数组succ[1..n]: 存储最短路径的有关信息。

(succ[i]表示顶点i到终点t的最短路径上顶点i的直接后继。

)原问题的最优值为cost[s]。

(1) 自底向上的迭代算法关键:根据递归公式确定迭代顺序(即子问题的求解顺序)。

原则:计算cost[i]时,顶点i的所有后继的cost值应先计算。

计算顺序:按图G的逆拓扑排序顺序。

算法SHORTEST_ROUTE_LEN1输入:有向网G的顶点数n, 邻接矩阵c[1..n, 1..n], 起点s和终点t , 1<=s, t<=n。

输出:G的从起点s到终点t的最短路径长度cost[s]和最短路径有关信息的数组succ[1..n]。

//对图G拓扑排序,结果存于数组a[1..n]中。

toposort(c, n, a)j=nwhile a[j]< >t j=j-1 //找出j使得a[j]=t 。

for i=j+1 to n cost[a[j]]=∞//排除无关的顶点。

cost[t]=0 //从终点开始迭代。

动态规划-最短路径问题

动态规划-最短路径问题

最短路径问题下图给出了一个地图,地图中每个顶点代表一个城市,两个城市间的连线代表道路,连线上的数值代表道路长度。

现在,我们想从城市a到达城市E。

怎样走才能使得路径最短,最短路径的长度是多少?设DiS[x]为城市x到城市E的最短路径长度(x表示任意一个城市);map[i,j]表示i,j两个城市间的距离,若map[i,j]=0,则两个城市不通;我们可以使用回溯法来计算DiS[x]:varS:未访问的城市集合;function search(who{x}):integer; {求城市who与城市E的最短距离} beginif Who=E Then Search←0 {找到目标城市}Else beginmin←maxint;{初始化最短路径为最大}for i 取遍所有城市 Doif(map[Who,i]>0{有路})and(i S{未访问})then beginS←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}beginS←除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 的最短路径也被求了两遍。

动态规划实现最短路径问题

动态规划实现最短路径问题

动态规划实现最短路径问题⼀、设计最短路径的动态规划算法 <算法导论>中⼀般将设计动态规划算法归纳为下⾯⼏个步骤: 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 } 上述代码是将给定的邻接矩阵从⽂件中读取 然后根据输⼊的邻接矩阵求出最短路径。

最短路径使用动态规划举例

最短路径使用动态规划举例

动态规划最短路径举例最短路径问题。

图中给出了一个地图,地图中每个顶点代表一个城市,两个城市间的连线代表道路,连线上的数值代表道路的长度。

现在,想从城市A到达城市E,怎样走路程最短,最短路程的长度是多少?【分析】把从A到E的全过程分成四个阶段,用k表示阶段变量,第1阶段有一个初始状态A,两条可供选择的支路ABl、AB2;第2阶段有两个初始状态B1、 B2,B1有三条可供选择的支路,B2有两条可供选择的支路……。

用dk(x k,x k+1)表示在第k阶段由初始状态x k到下阶段的初始状态x k+1的路径距离,Fk(x k)表示从第k阶段的x k到终点E的最短距离,利用倒推方法求解A到E的最短距离。

具体计算过程如下:S1:K=4,有:F4(D1)=3,F4(D2)=4,F4(D3)=3S2: K=3,有:F3(C1)=min{d3(C1,D1)+F4(D1),d3(C1,D2)+F4(d2)}=min{8,10}=8F3(C2)=d3(C2,D1)+f4(D1)=5+3=8F3(C3)=d3(C3,D3)+f4(D3)=8+3=11F3(C4)=d3(C4,D3)+f4(D3)=3+3=6S2: K=2,有:F2(B1)=min{d2(B1,C1)+F3(C1),d2(B1,C2)+f3(C2),d2(B1,C3)+F3(C3)}=min {9,12,14}=9F2(m)=min{d2(B2,c2)+f3(C2),d2(B2,C4)+F3(C4)}=min{16,10}=10S4:k=1,有:F1(A)=min{d1(A,B1)+F2(B1),d1(A,B2)+F2(B2)}=min{13,13}=13因此由A点到E点的全过程的最短路径为A—>B2一>C4—>D3—>E。

最短路程长度为13。

多段图最短路径_动态规划

多段图最短路径_动态规划

多段图最短路径【源程序】//本程序测试用例为作业题#include <stdio.h>//#define LOCALconstint MAX = 10000;int c[100][100];//图的存储矩阵int cost[100], path[100];intCreateGraph(){#ifdef LOCALfreopen("data.in", "r", stdin);freopen("data.out", "w", stdout);#endif // LOCALinti, j, k;int weight;//权重intvnum, arcnum;//顶点数,边数printf("请输入顶点的个数和边的个数:");scanf("%d%d",&vnum, &arcnum);for(i=0; i<vnum; i++)//初始化图的代价矩阵for(j=0; j<vnum; j++){c[i][j]=MAX;}printf("请输入边的两个顶点和权值:\n");for(k=0; k<arcnum; k++)//建立图的代价矩阵{scanf("%d%d%d",&i, &j, &weight);c[i][j]=weight;}return vnum;}intBackPath(int n)//求n个顶点的多段图的最短路径{for(inti=0; i<n-1; i++)//初始化两个数组{cost[i]=MAX;path[i]=-1;}cost[n-1]=0;//对于最后一个顶点要进行特殊的初始化path[n-1]=-1;for(inti=n-2; i>=0; i--)for(int j=i+1; j<n; j++)if(c[i][j]+cost[j]<cost[i]){cost[i]=c[i][j]+cost[j];path[i]=j;}printf("最短路径为:\n");printf("0");inti=0;while(path[i]>=0){printf("->%d",path[i]);i=path[i];}printf("\n\n");return cost[0];}int main(){int a = CreateGraph();printf("最短路径长度为:%d\n\n", BackPath(a));printf("cost数组为:\n");for(inti=0; i<a; i++)printf("%3d",cost[i]);printf("\n\n");printf("path数组为:\n");for(inti=0; i<a; i++)printf("%3d",path[i]);printf("\n");return 0;}【运行结果】。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

多段图最短路径【源程序】
//本程序测试用例为作业题
#include <stdio.h>
//#define LOCAL
constint MAX = 10000;
int c[100][100];//图的存储矩阵
int cost[100], path[100];
intCreateGraph()
{
#ifdef LOCAL
freopen("data.in", "r", stdin);
freopen("data.out", "w", stdout);
#endif // LOCAL
inti, j, k;
int weight;//权重
intvnum, arcnum;//顶点数,边数
printf("请输入顶点的个数和边的个数:");
scanf("%d%d",&vnum, &arcnum);
for(i=0; i<vnum; i++)//初始化图的代价矩阵
for(j=0; j<vnum; j++)
{
c[i][j]=MAX;
}
printf("请输入边的两个顶点和权值:\n");
for(k=0; k<arcnum; k++)//建立图的代价矩阵
{
scanf("%d%d%d",&i, &j, &weight);
c[i][j]=weight;
}
return vnum;
}
intBackPath(int n)//求n个顶点的多段图的最短路径
{
for(inti=0; i<n-1; i++)//初始化两个数组
{
cost[i]=MAX;
path[i]=-1;
}
cost[n-1]=0;//对于最后一个顶点要进行特殊的初始化path[n-1]=-1;
for(inti=n-2; i>=0; i--)
for(int j=i+1; j<n; j++)
if(c[i][j]+cost[j]<cost[i])
{
cost[i]=c[i][j]+cost[j];
path[i]=j;
}
printf("最短路径为:\n");
printf("0");
inti=0;
while(path[i]>=0)
{
printf("->%d",path[i]);
i=path[i];
}
printf("\n\n");
return cost[0];
}
int main()
{
int a = CreateGraph();
printf("最短路径长度为:%d\n\n", BackPath(a));
printf("cost数组为:\n");
for(inti=0; i<a; i++)
printf("%3d",cost[i]);
printf("\n\n");
printf("path数组为:\n");
for(inti=0; i<a; i++)
printf("%3d",path[i]);
printf("\n");
return 0;
}
【运行结果】。

相关文档
最新文档