实验三动态规划求多段图问题
动态规划_多段图_最小花费通路算法_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;}运行结果：。
多段图算法实验报告
算法分析与设计实验报告课题: 多段图******班级：计算机1101学号：**********目录一、实验目的二、实验内容三、实验要求四、概要设计五、详细设计六、实验心得一、实验目的加深理解动态规划策略，求出多段图中源点到各点的最短路径。
二、实验内容设G=(V,E)是一个赋权有向图，其顶点集V被划分成k>2个不相交的子集Vi: 1≤i≤k，其中，V1和Vk分别只有一个顶点s(称为源)和一个顶点t(称为汇)，图中所有的边(u,v)的始点和终点都在相邻的两个子集Vi和Vi＋1中：u∈Vi，v∈Vi＋1。
找一条从s到t的最短路线。
三、实验要求在上机前写出全部源程序；能在机器上正确运行程序；四、概要设计图采用邻接矩阵表示设P(i，j)是一条从Vi中的结点j到汇点t的最小成本路径，COST(i，j)是这条路的成本。
则从Vi中节点j到t的最小代价为：cost((i,j)=min{cost(i+1,l)+c (j,l) }, l∈Vi+1 ， j∈Vicost(i+1，l)是从Vi+1中节点l 到t的最小代价。
算法概要设计如下：多段图的向前处理算法procedure FGRAPH(G，k，n，P){//G有n个结点的k段图。
E是边集，c[i，j]是边<i,j>的成本。
P[1：k]是最小成本路径。
//COST[n]， D[n一1]，P[k]，r，j，k，nCOST[n]← 0for j←n-1to 1 by -1 do //计算COST[j]//{设r是一个这样的结点，(j，r) E且使c[j，r]+COST[r]取最小值COST[j]←c[j，r]+COST[r]D[j]←r} //向前对j-1进行决策//P[1]←1P[k]←nfor j←2 to k-1 do //找路径上的第j个节点//P[j]←D [ P[j-1] ]五、详细设计：#include <stdio.h>#include <stdlib.h>#define N 12#define K 5#define MAX 23767int cost[N][N];int path[K];typedef struct node{int v;int w;struct node *next;}node;node L[N];void init(node *L[]){int i, j;node *p, *q;for (i = 0; i < N; i++)for (j = 0; j < N; j++)cost[i][j] = MAX;cost[0][1] = 9;cost[0][2] = 7;cost[0][3] = 3;cost[0][4] = 2;cost[1][5] = 4;cost[1][6] = 2;cost[1][7] = 1;cost[2][5] = 2;cost[2][6] = 7;cost[3][7] = 11;cost[4][6] = 11;cost[4][7] = 8;cost[5][8] = 6;cost[5][9] = 5;cost[6][8] = 4;cost[6][9] = 3;cost[7][9] = 5;cost[7][10] = 6;cost[8][11] = 4;cost[9][11] = 2;cost[10][11] = 5;/*生成邻接表*/for (i = 0; i < N; i++)L[i] = (node *)malloc(sizeof(node));for (i = 0; i < N; i++){q = L[i];for (j = 0; j < N; j++)if (cost[i][j] > 0 && cost[i][j] < MAX){p = (node *)malloc(sizeof(node));p->v = j;p->w = cost[i][j];q->next = p;q = p;}q->next = NULL;}}void Method1() /*使用邻接矩阵存储*/{int i, j, maxlen, temp, v[N], d[N];for (i = 0; i < N; i++)v[i] = 0;for (i = N - 2; i >= 0; i--){for (maxlen = MAX, j = i + 1; j <= N - 1; j++)if (cost[i][j] > 0 && cost[i][j] + v[j] < maxlen){maxlen = cost[i][j] + v[j];temp = j;}v[i] = maxlen;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 Method2(node *L[]) /*使用邻接表存储*/ {int i, j, maxlen, temp, v[N], d[N];node *p;for (i = 0; i < N; i++)v[i] = 0;for (i = N - 2; i >= 0; i--){p = L[i]->next;maxlen = MAX;while (p){if (p->w + v[p->v] < maxlen){maxlen = p->w + v[p->v];temp = p->v;}p = p->next;}v[i] = maxlen;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 print(){int i;for (i = 0; i < K; i++)printf("%d ", path[i] + 1);printf("\n");}int main(){init(&L);printf("最短路径:\n ");Method1();print();printf("最短路径:\n");Method2(&L);print();system("pause");return 0;}六．实验心得通过本次试验，掌握了动态规划的思想，即如果一个问题的最优解可以分解为找子问题的最优解，那么即可使用动态规划。
一、用动态规划方法手工求解下面的问题：
一、用动态规划方法手工求解下面的问题：生产单位产品的成本费为1(千元)。
同时，在任何一个月内，生产能力所允许的最大生产批量为不超过6个单位。
又知每单位产品的库存费用为每月0.5(千元)，同时要求在第一个月开始之初， 及在第四个月末，均无产品库存。
问：在满足上述条件下，该厂应如何安排各个时期的生产与库存，使所花的总成本费用最低？解：这是一个多阶段问题，我们按照计划时间自然划分阶段。
状态变量k x 定义为第k 月月初时的存储量，决策变量k u 定义为第k 月的产量，记每个月需求量为k s ，则状态转移方程为：4,3,2,1,0,1=≥-+=+k x s u x x k k k k k第k 月允许决策集合 }60|{)(≤≤=k kk k u u x D阶段指标为阶段的生产成本费用和存储费用之和，即：⎩⎨⎧=>++=00035.0),(k k k k k k k u u u x u x v指标函数为∑==41,1),(k k k k n u x v V)(k k x f 表示由第k 月出发采用最优方案到第4月月底4个月时间内总成本{}1,2,3,4,)(),(min )(11)(=+=++∈k x f u x v x f k k k k k x D u k k k k k由条件可得到递推式：()⎪⎪⎩⎪⎪⎨⎧+⎩⎨⎧=>++==++∈}00035.0{min )(0)(11)(55k k k k k k x D u k k x f u u u x x f x f k k k k=4,3,2,1()}00035.0{min )(554444)(44444x f u u u x x f x D u +⎩⎨⎧=>++=∈)(44444354x D x x s x u ∈-=-+=4f (0)=7 4u =4 4f (1)=6.5 4u =3 4f (2)=6 4u =2 4f (3)=5.54u =1 4f (4)=24u =0()}00035.0{min )(443333)(33333x f u u u x x f x D u +⎩⎨⎧=>++=∈)(233343343x D x x x s x u ∈-+=-+= 3f (0) = min {12, 12.5, 13, 13.5, 11} = 11 3u =63f (1) = min {11.5, 12, 12.5, 13, 10.5} = 10.53u =6 3f (2) = min {8, 11.5, 12, 12.5, 10} = 8 3u =0 3f (3) = min {8, 11.5, 12, 9.5} = 8 3u =0 3f (4) = min {8, 11.5, 9} = 83u =0 3f (5) = min {8, 8.5} = 8 3u =0 3f (6) = min {5} = 53u =0()}00035.0{min )(332222)(22222x f u u u x x f x D u +⎩⎨⎧=>++=∈)(322232232x D x x x s x u ∈-+=-+=2f (0) = min {17, 17.5, 16, 17} = 162u =52f (1) = min {16.5, 17, 15.5, 16.5, 17.5} = 15.5 2u =4 2f (2) = min {16, 16.5, 15, 16, 17, 18} = 152u =3 2f (3) = min {12.5, 14, 14.5, 15.5, 16.5, 17.5, 15.5} = 12.52u =0 2f (4) = min {12.5, 14, 15, 16, 17, 15} = 12.52u =0 2f (5) = min {10.5, 14.5, 15.5, 16.5, 14.5} = 10.52u =0 2f (6) = min {11, 15, 16, 14} = 112u =0()}00035.0{min )(221111)(11111x f u u u x x f x D u +⎩⎨⎧=>++=∈)(211121121x D x x x s x u ∈-+=-+= 1f (0) = min {21, 21.5, 22, 20.5, 21.5} = 20.51u =5逆推可得 u={5, 0, 6, 0} x={0, 3, 0, 4}即第1个月生产5单位产品，第4个月生产6单位产品，第2、3月不生产。
算法设计与分析-多段图最短路径问题
算法设计与分析-多段图最短路径问题关于多段图最短路径问题的探讨摘要：本⽂主要描述的是分别⽤动态规划法、贪⼼法和分⽀限界法来解决多段图最短路径问题时的情况，并在附录中附有实际问题的程序来辅助阐述观点。
⽂章⾸先阐述了各个⽅法的原理，主要的思路是通过输⼊⼀组数据，⽐较三者的输出结果的准确性以及运⾏时间，以之为基础来分析、讨论三者的性能区别。
另外，众所周知，多段图是有向图的⼀个简单的模型，它在有向图的基础上忽略了两点之间的线的双向性的问题，并且对点与点之间的线有很多的要求，从⽽把图简化为可分为⼏段的模式，⽂章最后讲述了若这⼏种⽅法运⾏到有向图中的情况，⼏种⽅法的对⽐和它们⽐较适应的使⽤情况的讨论，并给出了⾃⼰的建议。
关键字：多段图最短路径问题动态规划法分⽀限界法多段图与有向图的关系有向图最短路径算法引⾔：当前社会，关于最短路径的问题屡屡出现。
例如在开车⾃驾游的⼀个过程中，排除其他影响因素，从⼀个地点到另⼀点，这个时候必然是希望有⼀条距离最短的路程来尽量减少消耗的时间以及花费的（它们在模型中被称为代价），市场上对该问题的解决有很⼤的需求，因此，这⾥我将讨论多段图的最短路径的问题。
在早些时间的课程中，我们学习过数据结构这门课程，其中就包括最短路径这⽅⾯的讨论。
当时⽼师给我们介绍了分别⾯向单源（Dijkstra算法）与⾮单源（Floyd算法）两种问题的算法法---,这是我们最早的对最短路径⽅⾯的理解，也是我们接触的⽐较早的关于图的问题。
在这学期的算法课程中，我们学习了许多了⽅法，包括贪⼼法、动态规划法等算法，它们把以前学习的许多⽅法都命名并归纳分类起来，其中有许多算法都是可以⽤来解决这个最短路径的问题的，并且该问题作为⼀个图的问题，对该问题的继续探讨优化的需求很⼤，本⽂将就不同算法在解决该最短路径问题时的不同⽅法进⾏对⽐并给出该问题在不同基础上不同的最终解决⽅案。
由于时间的限制，本⽂将重点分析动态规划法下的情况，并会对图的情况加以简化、限制，最后会对其他的图做⼀些拓展。
多段图问题_动态规划法
多段图问题_动态规划法先简单叙述⼀下动态规划的步骤问题和思路代码如下1 #include<bits/stdc++.h>2 using namespace std;3 int cost[10];4 int path[10];5 int array1[10][10];6 int main()7 {8 memset(cost,0,sizeof(cost));9 memset(path,0,sizeof(path));10 memset(array1,0,sizeof(array1));11 cout << "请输⼊多段图的边数" << endl;12 int m;//1813 cin >> m;14 cout << "请依次输⼊多段图的起点终点和路径长度" << endl;15 int start;16 int stop;17 int length;18 for(int i=0;i<18;i++){19 cin >> start >> stop >> length;20 array1[start][stop]=length;21 }22 for(int i=8;i>=0;i--){23 cost[i]=9999;24 for(int j=i;j<10;j++){25 if(array1[i][j]!=0){//等于零表⽰之间没有路26 if(array1[i][j]+cost[j]<cost[i]){//此时找到⼀条更短的路27 path[i]=j;//更新path[i]28 cost[i]= array1[i][j]+cost[j];//更新从该节点出发的最短路径29 }30 }31 }32 }33 cout << "最短路径长度是" << cost[0];34 cout <<endl;35 cout << "最短路径为"<< endl;36 int i=0;37 cout << "0--->";38 while(true){39 cout << path[i];40 i=path[i];41 if(i==9){42 break;43 }44 cout << "--->" ;45 }46 return 0;47 }运⾏结果如下。
求解多段图问题的并行动态规划算法
求解多段图问题的并行动态规划算法崔焕庆;王英龙【期刊名称】《计算机应用与软件》【年(卷),期】2011(028)012【摘要】Multistage graph problem is a special single-source shortest path problem. Based on two kinds of implementations of sequential dynamic programming method, two parallel algorithms with vertex-number-based task partition in cluster are given. Both of them are implemented by MPI. Experimental results indicated that these algorithms have lower time and communication complexity and higher speedup ratio. The algorithms can also be used in any structure of cluster and is of high universality.%多段图问题是一类特殊的单源最短路径问题.在串行动态规划算法的两种实现方法的基础上,根据图中顶点的编号,提出两种在集群环境下进行任务分割的并行化求解方法,并使用MPI进行实现.实验结果表明,所提出的算法具有较高的加速比和较低的通信复杂度、时间复杂度.算法不限于某种结构的集群,通用性强.【总页数】3页(P32-34)【作者】崔焕庆;王英龙【作者单位】山东科技大学信息科学与工程学院山东青岛266510;山东省计算机网络重点实验室山东济南250014;山东省计算中心山东济南250014;山东省计算机网络重点实验室山东济南250014;山东省计算中心山东济南250014【正文语种】中文【中图分类】TP30【相关文献】1.基于改进动态规划算法的复杂网络图最短路径求解 [J], 房茂燕;汪民乐;尹香麒2.求解并行加热炉群调度问题的三阶段算法 [J], 李铁克;王柏琳;赵艳艳3.求解最大团问题的并行多层图划分方法 [J], 顾军华;霍士杰;武君艳;尹君;张素琪4.基于二叉决策图的状态组合爆炸问题并行求解方法 [J], 叶雄;杨皓栋;;5.贪心核加速动态规划算法求解折扣{0-1}背包问题 [J], 史文旭;杨洋;鲍胜利因版权原因，仅展示原文概要，查看原文内容请购买。
算法设计与分析实验报告
实验一找最大和最小元素与归并分类算法实现（用分治法）一、实验目的1．掌握能用分治法求解的问题应满足的条件；2．加深对分治法算法设计方法的理解与应用；3．锻炼学生对程序跟踪调试能力；4．通过本次实验的练习培养学生应用所学知识解决实际问题的能力。
二、实验内容1、找最大和最小元素输入n 个数，找出最大和最小数的问题。
2、归并分类将一个含有n个元素的集合，按非降的次序分类（排序）。
三、实验要求（1）用分治法求解问题（2）上机实现所设计的算法；四、实验过程设计（算法设计过程）1、找最大和最小元素采用分治法，将数组不断划分，进行递归。
递归结束的条件为划分到最后若为一个元素则max和min都是这个元素，若为两个取大值赋给max，小值给min。
否则就继续进行划分，找到两个子问题的最大和最小值后，比较这两个最大值和最小值找到解。
2、归并分类使用分治的策略来将一个待排序的数组分成两个子数组，然后递归地对子数组进行排序，最后将排序好的子数组合并成一个有序的数组。
在合并过程中，比较两个子数组的首个元素，将较小的元素放入辅助数组，并指针向后移动，直到将所有元素都合并到辅助数组中。
五、源代码1、找最大和最小元素#include<iostream>using namespace std;void MAXMIN(int num[], int left, int right, int& fmax, int& fmin); int main() {int n;int left=0, right;int fmax, fmin;int num[100];cout<<"请输入数字个数：";cin >> n;right = n-1;cout << "输入数字:";for (int i = 0; i < n; i++) {cin >> num[i];}MAXMIN(num, left, right, fmax, fmin);cout << "最大值为：";cout << fmax << endl;cout << "最小值为：";cout << fmin << endl;return 0;}void MAXMIN(int num[], int left, int right, int& fmax, int& fmin) { int mid;int lmax, lmin;int rmax, rmin;if (left == right) {fmax = num[left];fmin = num[left];}else if (right - left == 1) {if (num[right] > num[left]) {fmax = num[right];fmin = num[left];}else {fmax = num[left];fmin = num[right];}}else {mid = left + (right - left) / 2;MAXMIN(num, left, mid, lmax, lmin);MAXMIN(num, mid+1, right, rmax, rmin);fmax = max(lmax, rmax);fmin = min(lmin, rmin);}}2、归并分类#include<iostream>using namespace std;int num[100];int n;void merge(int left, int mid, int right) { int a[100];int i, j,k,m;i = left;j = mid+1;k = left;while (i <= mid && j <= right) {if (num[i] < num[j]) {a[k] = num[i++];}else {a[k] = num[j++];}k++;}if (i <= mid) {for (m = i; m <= mid; m++) {a[k++] = num[i++];}}else {for (m = j; m <= right; m++) {a[k++] = num[j++];}}for (i = left; i <= right; i++) { num[i] = a[i];}}void mergesort(int left, int right) { int mid;if (left < right) {mid = left + (right - left) / 2;mergesort(left, mid);mergesort(mid + 1, right);merge(left, mid, right);}}int main() {int left=0,right;int i;cout << "请输入数字个数：";cin >> n;right = n - 1;cout << "输入数字:";for (i = 0; i < n; i++) {cin >> num[i];}mergesort(left,right);for (i = 0; i < n; i++) {cout<< num[i];}return 0;}六、运行结果和算法复杂度分析1、找最大和最小元素图1-1 找最大和最小元素结果算法复杂度为O(logn）2、归并分类图1-2 归并分类结果算法复杂度为O(nlogn）实验二背包问题和最小生成树算法实现（用贪心法）一、实验目的1．掌握能用贪心法求解的问题应满足的条件；2．加深对贪心法算法设计方法的理解与应用；3．锻炼学生对程序跟踪调试能力；4．通过本次实验的练习培养学生应用所学知识解决实际问题的能力。
6.多段图问题
ForwardShortestPath(float c[][n], int k, int n) { float C[n]; int d[n], p[k]; C[0:n-2]=MAX; C[n-1]=0; for(i=n-2; i>=0; i--) for(j=i+1; j<=n-1; j++) if((c[i][j]>0)&&(c[i][j]+C[j]<C[i])) { C[i]=c[i][j]+C[j]; d[i]= j; } for(p[0]=0, p[k-1]=n-1, i=1; i<k-1; k++) p[i]=d[p[i-1]]; } 时间复杂度: 时间复杂度 邻接表 O(n+e) 邻接矩阵 O(n2)
向前递推算法
c[n][n]: <i,j>∈E, c[i][j]>0; < i,j >∉E, c[i][j]=-1; c[i][i]=0. ∈ C[n]: 各节点到汇点的最短路径， C[i] = min{c[i][ j] + C[ j]} 各节点到汇点的最短路径，
j∈ s V
d[n]: 各节点到 最小成本路径上的后向邻接节点 各节点到t最小成本路径上的后向邻接节点 p[k]: 存储 到t最小成本路径上的节点编号 存储s到 最小成本路径上的节点编号 最小成本路径上的节点编号.
xk ⇐(xk+1, L,xn-1,xn ), xk = opt{xi , Γk+1}, xi ∈Sk .
3) 向后递推
(x1, x2 ,L,xk-1) ⇒ xk , xk = opt{Γk−1, xi }, xi ∈Sk .
多段图 (multistage graph)
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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 printpath()
{ int i;
for(i=0;i<k;i++)
int path[k]; //存储最短路径的数组
void creatgraph() //创建图的(成本)邻接矩阵
{ int i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
scanf("%d",&cost[i][j]);//获取成本矩阵数据
}
void printgraph() //输出图的成本矩阵
printf("%d ",path[i]);
}
int main()
{
creatgraph();
pri34;输出使用向前递推算法所得的最短路径:\n");
printpath();
printf("\n输出使用向后递推算法所得的最短路径:\n");
printpath();
实验三动态规划求多段图问题
实验项目算法实验动态规划实验
一、实验目的
1.掌握动态规划算法的基本思想
2.掌握多段图的动态规划算法
3.选择邻接表或邻接矩阵方式来存储图
4、分析算法求解的复杂度。
二、实验内容
4.掌握动态规划算法的基本思想
5.掌握多段图的动态规划算法
6.选择邻接表或邻接矩阵方式来存储图
4、分析算法求解的复杂度。
{ int i,j;
printf("成本矩阵:\n");
for(i=0;i<n;i++)
{ for(j=0;j<n;j++)
printf("%d ",cost[i][j]);
printf("\n");
}
}
//使用向前递推算法求多段图的最短路径
void FrontPath()
{ int i,j,length,temp,v[n],d[n];
三、实验环境
程序设计语言：c++
编程工具：microsoft visual studio 2010
四、算法描述和程序代码
#include "stdio.h"
#define n 7 //图的顶点数
#define k 4 //图的段数
#define MAX 23767
int cost[n][n]; //成本值数组
printf("\n");
return 0;
}
五、实验结果截图
六、实验总结
在做实验的过程中，要按部就班，首先明确实验目的，然后进行分析，写算法程序，最后调试运行，不能粗枝大叶，做的过程要细心谨慎，自己不会的通过向别人请教，总之上机实践的过程会学到很多。
for(i=0;i<n;i++) v[i]=0;
for(i=n-2;i>=0;i--)
{ for(length=MAX,j=i+1;j<=n-1;j++)
if(cost[i][j]>0 && (cost[i][j])+v[j]<length)
{length=cost[i][j]+v[j]; temp=j;}