算法设计与分析 实验五

合集下载

达林算法实验报告

达林算法实验报告

课程名称计算及控制技术 指导教师 实验时间 姓名: 班级: 学号: 成绩:实验五 基于达林算法的控制系统设计一、实验目的:1掌握达林算法数字控制器的设计方法。

2掌握达林算法设计的控制器产生振铃现象的原因。

3 掌握消除振铃现象的方法。

二、实验内容:已知某过程对象的传递函数为:期望的闭环系统时间常数 ,采样周期 。

要求:1采用达林算法设计数字控制器;2 在simulink 环境下,搭建控制系统模型,进行实验仿真; 3判断有无振铃现象,若有则修改控制器消除之,仿真并分析系统在单位阶跃响应下的输出结果; 三、 实验结果与分析1 达林算法设计数字控制器16.03)(5.0+=-s es G ss T 25.00=s T 5.0=被控对象为一阶惯性环节,则广义对象脉冲传递函数,闭环系统脉冲函数和数字调节器脉冲传递函数分别如下:()111111111TT Ts s N TT e Ke e G z Z Kz s T s e z τ-------⎡⎤--==⎢⎥+⎣⎦-()()()111111T T TssNT T e z Y z ee z Z z R z sT s ez ττττφ-------⎛⎫- ⎪⎡⎤-⎝⎭===⎢⎥+⎣⎦-()1111111z 111T T T T T T TT T T N e e D z K e e z ez τττ---------⎛⎫⎛⎫--⎪ ⎪⎝⎭⎝⎭⎡⎤⎛⎫⎛⎫---- ⎪ ⎪⎢⎥⎝⎭⎝⎭⎣⎦=由题意可得:0.5τ= 3K = 10.6T = 00.25T T τ== 0.5T = 1N =带入上述()D z 可得:()()()()()0.50.510.250.60.50.50.51110.60.250.25113111e e z D z ee z e z-----------=⎡⎤----⎢⎥⎣⎦化简得:()220.86z 0.381.690.23 1.46zD z z z -=--2 基于达林算法的控制系统模型3 Matlab 仿真结果:4 判断有无振铃现象,若有则修改控制器消除之,仿真并分析系统在单位阶跃响应下的输出结果;由 ()()11111111T T T T u T TT T e e z z G z K e e z ττφφ------⎛⎫⎛⎫-- ⎪ ⎪⎝⎭⎝⎭==⎛⎫⎛⎫-- ⎪⎪⎝⎭⎝⎭求得极点T T z eτ-=恒大于零.所以该带纯滞后的一阶惯性系统环节组成的系统中,不存在振铃现象。

算法课设实验报告(3篇)

算法课设实验报告(3篇)

第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。

为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。

二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。

1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。

(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。

- 对每种算法进行时间复杂度和空间复杂度的分析。

- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。

(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。

- 编写三种排序算法的代码。

- 分析代码的时间复杂度和空间复杂度。

- 编写测试程序,生成随机测试数据,测试三种算法的性能。

- 比较三种算法的运行时间和内存占用。

2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。

(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。

- 分析贪心算法的正确性,并证明其最优性。

(3)实验步骤:- 分析活动选择问题的贪心策略。

- 编写贪心算法的代码。

- 分析贪心算法的正确性,并证明其最优性。

- 编写测试程序,验证贪心算法的正确性。

3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。

(2)实验内容:- 实现一个动态规划算法问题,如背包问题。

- 分析动态规划算法的正确性,并证明其最优性。

(3)实验步骤:- 分析背包问题的动态规划策略。

- 编写动态规划算法的代码。

- 分析动态规划算法的正确性,并证明其最优性。

- 编写测试程序,验证动态规划算法的正确性。

三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。

《算法设计与分析》实验大纲

《算法设计与分析》实验大纲

《算法设计与分析》课程实验教学大纲Design and Analysis of Computer Algorithm总学时 16 总学分 0.5 实验学时 16一、基本情况1. 课程性质:专业实践2. 设课方式:独立设课3. 适用专业:计算机科学与技术专业4. 开课学期:第5学期5. 实验教材:《算法设计与分析》实验指导书6. 先修课程:高级语言程序设计、离散数学、数据结构二、课程简介算法设计与分析实验将覆盖计算机软件实现中的大部分算法,具有一定的深度和广度,目的是让学生掌握递归与分治策略、动态规划、贪心算法、回溯法、分支限界法等算法思想;能独立运用相关算法策略来分析、解决实际问题并编程实现。

同时,算法设计与分析实验是对学生在软件设计方面的综合训练,包括问题分析,总体结构设计,程序设计基本技能和技巧等,以培养良好的编程风格和科学作风。

通过理论联系实际,最终提高学生动手操作的能力以及分析问题和解决问题的能力,培养对算法的复杂性进行分析的逻辑思维能力。

三、实验目的与任务实验是教学内容的重要一环,其目的一方面是为了让学生掌握算法设计与分析中的一些常用的典型的算法设计思想和方法;另一方面是为了让学生切实掌握各种算法的具体实现方法,培养学生的实际动手能力,加强学生创新思维能力的培养。

四、课程的基本要求(1)了解实验目的,熟悉实验环境。

(2)预习实验,准备好实验题目和操作步骤。

(3)能编译调试源程序,分析错误原因并加以修改,得出正确结果。

(4)能运用所学的知识正确分析程序得出的结果,并能给出改进的方案。

(5)将上述各项要求及实验结果编写成实验报告。

实验前学生要认真预习实验内容,按要求编写源程序及准备测试数据。

实验中,要按操作规程操作计算机,集中精力调试程序,并认真测试实验数据。

对实验程序的故障应自行分析解决,不拷贝其它人的成果。

对实验得出的结果能加以分析,提出改进的具体措施。

掌握递归与分治策略、动态规划、贪心算法、回溯法、分支限界法等算法思想;能独立运用相关算法策略分析问题、解决实际问题并编程实现。

算法实验报告范文

算法实验报告范文

算法实验报告范文《算法设计与分析》实验报告班级姓名学号年月日目录实验一二分查找程序实现…………………………………………………………………03页实验二棋盘覆盖问题(分治法).…………………………………………………………08页实验三0-1背包问题的动态规划算法设计……………………………………………….11页实验四背包问题的贪心算法………………………………………………………………14页实验五最小重量机器设计问题(回溯法)………………………………………………17页实验六最小重量机器设计问题(分支限界法)…………………………………………20页指导教师对实验报告的评语成绩:指导教师签字:年月日2实验一:二分查找程序实现一、实验时间:2022年10月8日,星期二,第一、二节地点:J13#328二、实验目的及要求目的:1、用c/c++语言实现二分搜索算法。

2、通过随机产生有序表的方法,测出在平均意义下算法比较次数随问题规模的变化曲线,并作图。

三、实验环境平台:Win732位操作系统开发工具:Codeblock10.05四、实验内容对已经排好序的n个元素a[0:n-1],现在要在这n个元素中找出一特定元素某。

五、算法描述及实验步骤算法描述:折半查找法也称为二分查找法,它充分利用了元素间的次序关系,采用分治策略,可在最坏的情况下用O(logn)完成搜索任务。

它的基本思想是,将n个元素分成个数大致相同的两半,取a[n/2]与欲查找的某作比较,如果某=a[n/2]则找到某,算法终止。

如果某a[n/2],则我们只要在数组a的右半部继续搜索某。

二分搜索法的应用极其广泛,而且它的思想易于理解。

确定算法复杂度基本步骤:1、首先设定问题规模n;2、随即产生递增数列;3、在n个有序数中随机取一个作为待查找量,搜索之;4、记录查找过程中的比较次数,再次生成新的有序表并查找,记录查找次数,每个数组重复10次;5、改变问题规模n重复上述步骤2~4,n取100、200……1000;6、依实验数据作图,并与理论图作比较;7、二分搜索算法平均查找次数:问题规模为n时,平均查找次数为:A(n)=Int(logn)+1/2//Int()函数为向下取整3即二分搜索算法对于含有n个数据的有序表L平均作了约Int(logn)+1/2次的查找操作。

数字整型算法实验报告(3篇)

数字整型算法实验报告(3篇)

第1篇一、实验目的1. 理解数字整型算法的基本原理和方法。

2. 掌握常用的数字整型算法,如整数乘法、除法、取余、排序等。

3. 培养算法设计与分析能力,提高编程实践能力。

二、实验内容1. 整数乘法算法2. 整数除法算法3. 整数取余算法4. 快速排序算法5. 堆排序算法三、实验原理1. 整数乘法算法:利用位运算,将两个整数进行逐位相乘,然后求和得到最终结果。

2. 整数除法算法:利用长除法原理,将除数逐步减去被除数的倍数,直到余数小于除数,此时商即为最终结果。

3. 整数取余算法:与整数除法类似,只需取除法的余数即可。

4. 快速排序算法:采用分治策略,将待排序的序列分为两部分,一部分大于等于基准值,另一部分小于基准值,然后递归地对这两部分进行排序。

5. 堆排序算法:利用堆这种数据结构,通过调整堆的性质来实现排序。

四、实验步骤1. 整数乘法算法实现```cint multiply(int a, int b) {int result = 0;while (b != 0) {if (b & 1) {result += a;}a <<= 1;b >>= 1;}return result;}```2. 整数除法算法实现```cint divide(int a, int b) {if (a == 0) return 0;int sign = (a > 0) ^ (b > 0) ? -1 : 1;long long dividend = abs((long long)a), divisor = abs((long long)b); long long quotient = 0;while (dividend >= divisor) {dividend -= divisor;quotient++;}return sign (int)quotient;}```3. 整数取余算法实现```cint remainder(int a, int b) {return a % b;}```4. 快速排序算法实现```cvoid quickSort(int arr[], int low, int high) { if (low < high) {int pivot = partition(arr, low, high); quickSort(arr, low, pivot - 1);quickSort(arr, pivot + 1, high);}}int partition(int arr[], int low, int high) { int pivot = arr[high];int i = low - 1;for (int j = low; j < high; j++) {if (arr[j] <= pivot) {i++;swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return i + 1;}```5. 堆排序算法实现```cvoid heapify(int arr[], int n, int i) {int largest = i;int left = 2 i + 1;int right = 2 i + 2;if (left < n && arr[left] > arr[largest]) { largest = left;}if (right < n && arr[right] > arr[largest]) { largest = right;}if (largest != i) {swap(&arr[i], &arr[largest]);heapify(arr, n, largest);}}void heapSort(int arr[], int n) {for (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, n, i);}for (int i = n - 1; i > 0; i--) {swap(&arr[0], &arr[i]);heapify(arr, i, 0);}}```五、实验结果与分析1. 整数乘法算法:通过位运算实现,效率较高,适用于大整数乘法运算。

算法设计与分析实验报告棋盘覆盖问题

算法设计与分析实验报告棋盘覆盖问题

算法设计与分析实验报告棋盘覆盖问题贵州大学计算机科学与技术学院计算机科学与技术系上机实验报告课程名称:算法设计与分析班级:信计101班实验日期:2013-9-30 姓名: 张胜学号:1007010162 指导教师:程欣宇实验序号:一实验成绩: 一、实验名称分治算法实验 - 棋盘覆盖问题二、实验目的及要求1、熟悉递归算法编写;2、理解分治算法的特点;3、掌握分治算法的基本结构。

三、实验环境Visual C++四、实验内容根据教材上分析的棋盘覆盖问题的求解思路,进行验证性实验;要求完成棋盘覆盖问题的输入、分治求解、输出。

有余力的同学尝试消去递归求解。

五、算法描述及实验步骤分治算法原理:分治算法将大的分解成形状结构相同的子问题,并且不断递归地分解,直到子问题规模小到可以直接求解。

棋盘覆盖问题描述:在一个2k x 2k个方格组成的棋盘中恰有一个方格与其他的不同称为特殊方格,想要求利用四种L型骨牌(每个骨牌可覆盖三个方格)不相互重叠覆盖的将除了特殊方格外的其他方格覆盖。

实验步骤:1、定义用于输入和输出的数据结构;2、完成分治算法的编写;3、测试记录结构;4、有余力的同学尝试不改变输入输出结构,将递归消除,并说明能否不用栈,直接消除递归,为什么,六、调试过程及实验结果实验运行结果:七、总结通过本次实验,我更深的理解了递归和分治策略。

代码是书上的算法,加上主函数就行了,用的是C语言编写,很长时间没用了,感觉有点生疏。

实验结果有点问题,就是覆盖棋盘时,并不是按照1,2,3….的字符顺序,而是按照很乱的顺序输出字符,这个我不知道怎么解决,就没解决。

八、附录#include "stdio.h"#include "conio.h"int board[8][8] ={{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0 ,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0}};int tile=0;void chessBoard(int tr, int tc, int dr, intdc, int size){int t=tile++,s=size/2;if (size==1) return;if (dr<tr+s&&dc<tc+s)chessBoard(tr,tc,dr,dc,s);else {board[tr+s-1][tc+s-1]=t;chessBoard(tr,tc,tr+s-1,tc+s-1,s);}if(dr <tr+s && dc >= tc+s)chessBoard(tr,tc+s,dr,dc,s);else {board[tr+s-1][tc+s]=t;chessBoard(tr,tc+s,tr+s-1,tc+s,s);} if(dr >= tr+s&&dc<tc+s)chessBoard(tr+s,tc,dr, dc,s);else {board[tr+s][tc+s-1]=t;chessBoard(tr+s,tc,tr+s,tc+s-1,s);} if(dr >= tr+s &&dc>=tc+s) chessBoard(tr+s,tc+s,dr,dc,s);else {board[tr+s][tc+s]=t;chessBoard(tr+s,tc+s,tr+s,tc+s,s);} }main(){int i ,j;chessBoard(0,0,5,5,8);for(i=0;i <8;i++){for( j=0;j <8;j++) {if(board[i][j]<10)printf("0");printf("%d",board[i][j]);printf(" ");}printf( "\n"); } getchar();}。

算法分析与设计实验报告合并排序快速排序

算法分析与设计实验报告:合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分,它涉及到解决问题的方法和步骤。

合并排序和快速排序是两种经典而常用的排序算法。

本文将对这两种排序算法进行分析和设计实验,通过对比它们的性能和效率,以期得出最优算法。

二、合并排序合并排序是一种分治算法,它将原始数组不断分解为更小的数组,直到最后细分为单个元素。

然后,再将这些单个元素两两合并,形成一个有序数组。

合并排序的核心操作是合并两个有序的数组。

1. 算法步骤(1)将原始数组分解为更小的子数组,直到每个子数组只有一个元素;(2)两两合并相邻的子数组,同时进行排序,生成新的有序数组;(3)重复步骤(2),直到生成最终的有序数组。

2. 算法性能合并排序的最优时间复杂度为O(nlogn),其中n为待排序数组的长度。

无论最好情况还是最坏情况,合并排序的复杂度都相同。

合并排序需要额外的存储空间来存储临时数组,所以空间复杂度为O(n)。

三、快速排序快速排序也是一种分治算法,它将原始数组根据一个主元(pivot)分成两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元。

然后,递归地对这两个子数组进行排序,最后得到有序数组。

快速排序的核心操作是划分。

1. 算法步骤(1)选择一个主元(pivot),可以是随机选择或者固定选择第一个元素;(2)将原始数组根据主元划分为两个子数组,一个子数组的元素都小于主元,另一个子数组的元素都大于主元;(3)递归地对这两个子数组进行快速排序;(4)重复步骤(2)和(3),直到每个子数组只有一个元素,即得到最终的有序数组。

2. 算法性能快速排序的平均时间复杂度为O(nlogn),其中n为待排序数组的长度。

最坏情况下,当每次选择的主元都是最小或最大元素时,时间复杂度为O(n^2)。

快速排序是原地排序,不需要额外的存储空间,所以空间复杂度为O(1)。

四、实验设计为了验证合并排序和快速排序的性能和效率,我们设计以下实验:1. 实验目的:比较合并排序和快速排序的时间复杂度和空间复杂度。

算法设计与分析实验报告

实验一找最大和最小元素与归并分类算法实现(用分治法)一、实验目的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.通过本次实验的练习培养学生应用所学知识解决实际问题的能力。

常见算法设计实验报告(3篇)

第1篇一、实验目的通过本次实验,掌握常见算法的设计原理、实现方法以及性能分析。

通过实际编程,加深对算法的理解,提高编程能力,并学会运用算法解决实际问题。

二、实验内容本次实验选择了以下常见算法进行设计和实现:1. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。

2. 查找算法:顺序查找、二分查找。

3. 图算法:深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)。

4. 动态规划算法:0-1背包问题。

三、实验原理1. 排序算法:排序算法的主要目的是将一组数据按照一定的顺序排列。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。

2. 查找算法:查找算法用于在数据集中查找特定的元素。

常见的查找算法包括顺序查找和二分查找。

3. 图算法:图算法用于处理图结构的数据。

常见的图算法包括深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)等。

4. 动态规划算法:动态规划算法是一种将复杂问题分解为子问题,通过求解子问题来求解原问题的算法。

常见的动态规划算法包括0-1背包问题。

四、实验过程1. 排序算法(1)冒泡排序:通过比较相邻元素,如果顺序错误则交换,重复此过程,直到没有需要交换的元素。

(2)选择排序:每次从剩余元素中选取最小(或最大)的元素,放到已排序序列的末尾。

(3)插入排序:将未排序的数据插入到已排序序列中适当的位置。

(4)快速排序:选择一个枢纽元素,将序列分为两部分,使左侧不大于枢纽,右侧不小于枢纽,然后递归地对两部分进行快速排序。

(5)归并排序:将序列分为两半,分别对两半进行归并排序,然后将排序好的两半合并。

(6)堆排序:将序列构建成最大堆,然后重复取出堆顶元素,并调整剩余元素,使剩余元素仍满足最大堆的性质。

2. 查找算法(1)顺序查找:从序列的第一个元素开始,依次比较,直到找到目标元素或遍历完整个序列。

动态规划算法实现多段图的最短路径问题算法设计与分析实验报告

动态规划算法实现多段图的最短路径问题算法设计与分析实验报告算法设计与分析实验报告实验名称 动态规划算法实现多段图的最短路径问题 评分 实验日期 年 月 日 指导教师 姓名 专业班级 学号一.实验要求1. 理解最优子结构的问题。

有一类问题的活动过程可以分成若干个阶段,而且在任一阶段后的行为依赖于该阶段的状态,与该阶段之前的过程如何达到这种状态的方式无关。

这类问题的解决是多阶段的决策过程。

在50年代,贝尔曼(Richard Bellman )等人提出了解决这类问题的“最优化原理”,从而创建了最优化问题的一种新的算法设计方法-动态规划。

对于一个多阶段过程问题,是否可以分段实现最优决策,依赖于该问题是否有最优子结构性质,能否采用动态规划的方法,还要看该问题的子问题是否具有重叠性质。

最优子结构性质:原问题的最优解包含了其子问题的最优解。

子问题重叠性质:每次产生的子问题并不总是新问题,有些子问题被反复计算多次。

问题的最优子结构性质和子问题重叠性质是采用动态规划算法的两个基本要素。

2.理解分段决策Bellman 方程。

每一点最优都是上一点最优加上这段长度。

即当前最优只与上一步有关。

U s 初始值,u j 第j 段的最优值。

⎪⎩⎪⎨⎧+==≠}.{min ,0ijiji js w u u u3.一般方法1)找出最优解的性质,并刻画其结构特征;2)递归地定义最优值(写出动态规划方程);3)以自底向上的方式计算出最优值;4)根据计算最优值时得到的信息,构造一个最优解。

步骤1-3是动态规划算法的基本步骤。

在只需要求出最优值的情形,步骤4可以省略,步骤3中记录的信息也较少;若需要求出问题的一个最优解,则必须执行步骤4,步骤3中记录的信息必须足够多以便构造最优解。

二.实验内容1.编程实现多段图的最短路径问题的动态规划算法。

2.图的数据结构采用邻接表。

3.要求用文件装入5个多段图数据,编写从文件到邻接表的函数。

4.验证算法的时间复杂性。

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

实验五
一、实验目的与要求
1、了解动态规划的四个步骤;
2、对最优子结构性质的理解;
3、对具体问题进行动态规划的方法;
4、掌握矩阵连乘的算法实质;
二、实验题
假定有{A1,A2,…An}个矩阵,其中矩阵Ai与Ai+1可乘,请编程实现使矩阵乘法次数最少的加括号解!(用动态规划算法)
程序代码:
package Cy;
public class MatEven {
public static void main(String[] args) {
int[] Dim = {30,35,35,15,15,5,5,6,10,20,30,25};
int result = MatEven(Dim);
System.out.println("\n动态规划求的的最优策略相乘顺序导致的最少乘法数为:" + result);
}
public static int MatEven(int[] Dim){
//接受n个矩阵的维度数组Dim大小为2n
int n = Dim.length / 2; //有n个矩阵,编号0...n-1,编号为k的矩阵的维数是
Dim[2k] * Dim[2k+1]
int[][] Result = new int[n][n]; //最小代价矩阵 //初始化
for(int i = 0;i < n;i++)
Result[i][i] = 0;
//沿对角线填矩阵
for(int d = 1;d <= n-1;d++) //共n-1条对角线需要填 {
for(int i = 0;i <= n-d-1;i++) //第d条对角线的第一个点横为d {
//int j = i - d;
int j = i + d; //在第d条对角线上的点,横纵坐标的关j=i+d //这样就确定了一个位置(i,j)的坐标,然后来填(i,j)
int Min = 1000000000;
for(int k = i;k <= j-1;k++) //从第k个矩阵后面断开 {
//动态规划状态转移方程
int temp = Result[i][k] + Result[k+1][j] + (Dim[2*i]
* Dim[2*k + 1] * Dim[2*j+1]);
if( temp < Min) Min = temp;
}
Result[i][j] = Min;
}
}
return Result[0][n-1];
}
}
实验结果:
测试数组:
实验总结与分析:
首先明确一个问题,两个矩阵相乘必须满足前一矩阵的列数等于后一矩阵的行数。

动态规划的第一步是刻画最优解的结构,这里就用到了穷举搜索的方法。

设法让所研究的问题
的最优解包含其子问题的最优解,问题就容易解决。

动态规划问题中涉及两个重要的算法,穷举算法和递归算法
在矩阵连乘积最优计算次序问题中,当A1A2…An的最优完全加括号方式在Ak和Ak+1之间将矩阵链断开,由此确定的子链A1A2…Ak和Ak+1Ak+2…An的完全加括号方式也是最优的。

相关文档
最新文档