算法设计与分析---概率算法实验报告

合集下载

算法实验报告

算法实验报告

算法分析与设计实验报告算法实现题3-4(数学三角形问题):第一部分 实验内容(1)熟悉动态规范算法的思想。

(2)熟悉分析问题的最优子结构性质。

(3)掌握动态规划算法解决问题的一般思路第二部分 问题及算法1.求解问题的算法描述(1)问题描述: 给定n行数字组成的数字三角形,计算从三角形的自顶到底的一条路径,使该路径经过的数字的总和最大。

(2)算法描述:求第一层到最底层的“最大路径长度”,只需要求出第二层数字中到最底层的“最大路径长度”加上第一层的数字即可。

依靠此思想将问题分解成n-1个子问题,从倒数第二层开始计算每层到最底层的“最大路径长度”。

将数学三角形存在二维矩阵A[n][n]中,对于非底层的每个数向下走时只有两个选择,每次选择较大的数相加,自底至上的计算,将每个数到达底层的“最大路径长度”储存在数组A中,最终A[0][0]存储的就是第一层到最底层的“最大路径长度”。

(3)算法伪代码://求第一层到最底层的“最大路径长度”int triangle(int a[SIZE][SIZE],int n){– 2 to 0)for (row = nfor (col = 0 to row)if (A[row + 1][col] > A[row + 1][col + 1])A[row][col] += A[row + 1][col];elseA[row][col] += A[row + 1][col+1];return A[0][0];}2. 算法实现的关键技巧(1)分解原问题为规模更小的子问题,并且分析问题是否具有最优子结构性质。

求第一层到最底层的“最大路径长度”,可以看作求第一层的数加上第二层数字中到最底层的“最大路径长度”。

第二层某数到最底层的“最大路径长度”等于该数加上第三层中该数可以到达的数字到最底层的“最大路径长度”……这样分解下去,就可以将问题分为多个子问题。

大问题的最优解包括子问题的最优解,满足最优子结构性质。

算法设计与分析实验报告

算法设计与分析实验报告

算法设计与分析实验报告指导老师:沙莎学院:信息科学与工程学院班级:计科0508姓名:戚婕学号:10完成日期:2007年12月目录实验一分治法 (2)实验要求 (2)实验内容 (2)核心算法 (2)程序代码 (4)实验结果 (8)实验二贪心法 (10)实验要求 (10)实验内容 (10)核心算法 (10)程序代码 (12)实验结果 (18)实验三动态规划 (20)实验要求 (20)实验内容 (20)核心算法 (20)程序代码 (21)实验结果 (24)实验四深度优先搜索 (26)实验要求 (26)实验内容 (26)核心算法 (26)程序代码 (27)实验结果 (28)实验五回溯法 (30)实验要求 (30)实验内容 (30)核心算法 (30)程序代码 (31)实验结果 (33)实验一分治法一.实验要求1.了解用分治法求解的问题:当要求解一个输入规模为n,且n的取值相当大的问题时,如果问题可以分成k个不同子集合,得到k个不同的可独立求解的子问题,其中1<k≤n,而且子问题与原问题性质相同,原问题的解可由这些子问题的解合并得出。

那末,对于这类问题分治法是十分有效的。

2.掌握分治法的一般控制流程。

DanC(p,q)global n,A[1:n]; integer m,p,q; 验内容1.编程实现归并排序算法和快速排序算法,程序中加入比较次数的计数功能,输出排序结果和比较次数。

2.输入10组相同的数据,验证排序结果和完成排序的比较次数。

3.与复杂性函数所计算的比较次数比较。

4.用表格列出比较结果。

5.给出文字分析。

三.程序算法1. 归并排序算法procedure MERGESORT(low,high)快速排序算法QuickSort(p,q)序代码1.归并排序#include<>#include<>#include<>#include<>#define M 11typedef int KeyType;typedef int ElemType;struct rec{KeyType key;ElemType data;};typedef rec sqlist[M];class guibing{public:guibing(sqlist b){for(int i=0;i<M;i++)r[i]=b[i];}void output(sqlist r,int n){for(int i=0;i<n;i++)cout<<setw(4)<<r[i].key;cout<<endl;}void xuanze(sqlist b,int m,int n){int i,j,k;for(i=m;i<n-1;i++){k=i;for(j=i;j<n;j++)if(b[k].key>b[j].key) k=j;if(k!=i){rec temp=b[k];b[k]=b[i];b[i]=temp;}}}void merge(int l,int m,int h,sqlist r2) {xuanze(r,l,m);xuanze(r,m,h);output(r,M);int i,j,k;k=i=l;for(j=m;i<m&&j<h;k++){if(r[i].key<=r[j].key){r2[k]=r[i];i++;}else{r2[k]=r[j];j++;}output(r2,M);}while(j<h){r2[k]=r[j];j++;k++;}while(i<=m){r2[k]=r[i];i++;k++;}output(r2,M);}private:sqlist r;};void main(){cout<<"guibingfa1运行结果:\n";sqlist a,b;int i,j=0,k=M/2,n=M;srand(time(0));for(i=0;i<M;i++){a[i].key=rand()%80;b[i].key=0;}guibing gx(a);cout<<"排序前数组:\n";(a,M);cout<<"数组排序过程演示:\n";(j,k,n,b);cout<<"排序后数组:\n";(b,M);();}2.快速排序#include<>#include<>#include<>#include<>#define MAXI 10typedef int KeyType;typedef int ElemType;struct rec{KeyType key;ElemType data;};typedef rec sqlist[MAXI];class kuaisu{public:kuaisu(sqlist a,int m):n(m){for(int i=0;i<n;i++) b[i]=a[i];}void quicksort(int s,int t){int i;if(s<t){i=part(s,t);quicksort(s,i-1);quicksort(i+1,t);}else return;}int part(int s,int t){int i,j;rec p;i=s;j=t;p=b[s];while(i<j){while(i<j&&b[j].key>=j--;b[i]=b[j];while(i<j&&b[i].key<=i++;b[j]=b[i];}b[i]=p;output();return i;}void output(){for(int i=0;i<n;i++)cout<<setw(4)<<b[i].key;cout<<endl;}private:sqlist b;int n;};void main(){cout<<"运行结果:\n";sqlist a1;int i,n=MAXI,low=0,high=9;srand(time(0));for(i=0;i<n;i++)a1[i].key=rand()%80;kuaisu px(a1,n);v1.0 可编辑可修改cout<<"数组排序过程演示:\n";(low,high);cout<<"排序后数组:\n";();();}五.实验结果1.归并排序2.快速排序实验二贪心法一.实验要求1.优化问题有n个输入,而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组成,而把满足约束条件的子集称为该问题的可行解。

算法分析_实验报告

算法分析_实验报告

一、实验目的1. 理解算法分析的基本概念和方法。

2. 掌握时间复杂度和空间复杂度的计算方法。

3. 比较不同算法的效率,分析算法的适用场景。

4. 提高编程能力,培养算法思维。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm三、实验内容本次实验主要分析了以下几种算法:1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 编写各种排序算法的Python实现代码。

2. 分别对长度为10、100、1000、10000的随机数组进行排序。

3. 记录每种排序算法的运行时间。

4. 分析算法的时间复杂度和空间复杂度。

5. 比较不同算法的效率。

五、实验结果与分析1. 冒泡排序```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]```时间复杂度:O(n^2)空间复杂度:O(1)冒泡排序是一种简单的排序算法,其时间复杂度较高,适用于小规模数据排序。

2. 选择排序```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]```时间复杂度:O(n^2)空间复杂度:O(1)选择排序也是一种简单的排序算法,其时间复杂度与冒泡排序相同,同样适用于小规模数据排序。

3. 插入排序```pythondef insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = key```时间复杂度:O(n^2)空间复杂度:O(1)插入排序是一种稳定的排序算法,其时间复杂度与冒泡排序和选择排序相同,适用于小规模数据排序。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- 编写贪心算法的代码。

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

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

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

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

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

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

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

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

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

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

算法分析与设计实验报告

算法分析与设计实验报告

算法分析与设计实验报告专业班级:姓名:学号:指导老师:实验一递归算法的设计与实现•计算整数的非负整数次幂(1)设计思路对于34按步骤可以分析:34=32*3232=31*3131=31*1对于33按步骤可以分析:33=32*31;32=31*31;31=31*1;分析可以得到:当x n中n为奇数时,x n=x*(x n/2)2当x n中n为偶数的,x n=(x n/2)2;当n/2=0;return 1;一步步进行递归返回计算,如果n位奇数,在进行一部乘以x 否则返回运算结果(2)源程序代码#include<iostream>using namespace std;int power(int x,int n){int y;if(n==0){y=1;}else{y=power(x,n/2);y=y*y;if(n%2==1){y=y*x;}}return y;}void main(){cout<<"请输入一个底数X:";int x;cin>>x;cout<<"请输入一个指数Y: ";int y;cin>>y;if(y<0){cout<<"你的输入有误:请重新输入:"<<endl; cin>>y;}int c;c=power(x,y);cout<<x<<"的"<<y<<"次幂的结果是"<<c<<endl; }(3)代码运行结果(4)时间复杂度令n=2k,则可以得到:f(n)=g(k)=k+1=logn+1=O(logn)2.基于递归算法的插入排序(1)设计思路通过主函数传来一个数组的首地址和数组的长度,然后利用递归的原理,当n=0;程序返回,执行入栈的递归程序,依次比较2个数的大小,3个数的大小等,根据比较的结果将第n个数插入适当的位置。

算法设计与分析实验报告

算法设计与分析实验报告

算法设计与分析实验报告算法设计与分析实验报告引言:算法设计与分析是计算机科学中的重要课程,它旨在培养学生解决实际问题的能力。

本次实验旨在通过设计和分析不同类型的算法,加深对算法的理解,并探索其在实际应用中的效果。

一、实验背景算法是解决问题的步骤和方法的描述,是计算机程序的核心。

在本次实验中,我们将重点研究几种经典的算法,包括贪心算法、动态规划算法和分治算法。

通过对这些算法的设计和分析,我们可以更好地理解它们的原理和应用场景。

二、贪心算法贪心算法是一种基于局部最优选择的算法,它每一步都选择当前状态下的最优解,最终得到全局最优解。

在实验中,我们以背包问题为例,通过贪心算法求解背包能够装下的最大价值物品。

我们首先将物品按照单位重量的价值从大到小排序,然后依次将能够装入背包的物品放入,直到背包无法再装下物品为止。

三、动态规划算法动态规划算法是一种通过将问题分解为子问题,并记录子问题的解来求解整体问题的算法。

在实验中,我们以斐波那契数列为例,通过动态规划算法计算斐波那契数列的第n项。

我们定义一个数组来保存已经计算过的斐波那契数列的值,然后通过递推公式将前两项的值相加得到后一项的值,最终得到第n项的值。

四、分治算法分治算法是一种将问题分解为更小的子问题,并通过递归求解子问题的算法。

在实验中,我们以归并排序为例,通过分治算法对一个无序数组进行排序。

我们首先将数组分成两个子数组,然后对子数组进行递归排序,最后将两个有序的子数组合并成一个有序的数组。

五、实验结果与分析通过对以上三种算法的设计和分析,我们得到了以下实验结果。

在贪心算法中,我们发现该算法能够在有限的时间内得到一个近似最优解,但并不能保证一定得到全局最优解。

在动态规划算法中,我们发现该算法能够通过记忆化搜索的方式得到准确的结果,但在问题规模较大时,其时间复杂度较高。

在分治算法中,我们发现该算法能够将问题分解为更小的子问题,并通过递归求解子问题,最终得到整体问题的解。

算法设计与分析实验报告格式

算法设计与分析实验报告一实验名称统计数字问题评分实验日期年月日指导教师刘长松姓名刘飞初专业班级计算机0901 学号10一.实验要求1、掌握算法的计算复杂性概念。

2、掌握算法渐近复杂性的数学表述。

3、掌握用C++语言描述算法的方法。

4.实现具体的编程与上机实验,验证算法的时间复杂性函数。

二.实验内容统计数字问题1、问题描述一本书的页码从自然数1 开始顺序编码直到自然数n。

书的页码按照通常的习惯编排,每个页码都不含多余的前导数字0。

例如,第6 页用数字6 表示,而不是06 或006 等。

数字计数问题要求对给定书的总页码n,计算出书的全部页码中分别用到多少次数字0,1,2, (9)2、编程任务给定表示书的总页码的10 进制整数n (1≤n≤109) 。

编程计算书的全部页码中分别用到多少次数字0,1,2, (9)三.程序算法将页码数除以10,得到一个整数商和余数,商就代表页码数减余数外有多少个1—9作为个位数,余数代表有1—余数本身这么多个数作为剩余的个位数,此外,商还代表1—商本身这些数出现了10次,余数还代表剩余的没有计算的商的大小的数的个数。

把这些结果统计起来即可。

四.程序代码#include<iostream.h>int s[10]; //记录0~9出现的次数int a[10]; //a[i]记录n位数的规律void sum(int n,int l,int m){if(m==1){int zero=1;for(int i=0;i<=l;i++) //去除前缀0{s[0]-=zero;zero*=10;}}if(n<10){for(int i=0;i<=n;i++){s[i]+=1;}return;}//位数为1位时,出现次数加1//位数大于1时的出现次数for(int t=1;t<=l;t++)//计算规律f(n)=n*10^(n-1) {m=1;int i;for(i=1;i<t;i++)m=m*10;a[t]=t*m;}int zero=1;for(int i=0;i<l;i++){zero*= 10;} //求出输入数为10的n次方int yushu=n%zero; //求出最高位以后的数int zuigao=n/zero; //求出最高位zuigaofor(i=0;i<zuigao;i++){s[i]+=zero;} //求出0~zuigao-1位的数的出现次数for(i=0;i<10;i++){s[i]+=zuigao*a[l];} //求出与余数位数相同的0~zuigao-1位中0~9出现的次数//如果余数是0,则程序可结束,不为0则补上所缺的0数,和最高位对应所缺的数if(yushu==0) //补上所缺的0数,并且最高位加1{s[zuigao]++;s[0]+=l;}else{i=0;while((zero/=10)>yushu){i++;}s[0]+=i*(yushu+1);//补回因作模操作丢失的0s[zuigao]+=(yushu+1);//补回最高位丢失的数目sum(yushu,l-i-1,m+1);//处理余位数}}void main(){int i,m,n,N,l;cout<<"输入数字要查询的数字:";cin>>N;cout<<'\n';n = N;for(i=0;n>=10;i++){n/=10;} //求出N的位数n-1l=i;sum(N,l,1);for(i=0; i<10;i++){cout<< "数字"<<i<<"出现了:"<<s[i]<<"次"<<'\n';}}五.程序调试中的问题调试过程中总是有这样那样的问题,通过一步步的修改,最终得以实现。

算法设计与分析实验报告

实验一找最大和最小元素与归并分类算法实现(用分治法)一、实验目的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. 实验一:排序算法分析- 实验内容:分析比较冒泡排序、选择排序、插入排序、快速排序、归并排序等基本排序算法的效率。

- 实验步骤:1. 编写各排序算法的C++实现。

2. 使用随机生成的不同规模的数据集进行测试。

3. 记录并比较各算法的运行时间。

4. 分析不同排序算法的时间复杂度和空间复杂度。

2. 实验二:背包问题- 实验内容:使用贪心算法、回溯法、分支限界法解决0-1背包问题。

- 实验步骤:1. 编写贪心算法、回溯法和分支限界法的C++实现。

2. 使用标准测试数据集进行测试。

3. 对比分析三种算法的执行时间和求解质量。

3. 实验三:矩阵链乘问题- 实验内容:使用动态规划算法解决矩阵链乘问题。

- 实验步骤:1. 编写动态规划算法的C++实现。

2. 使用不同规模的矩阵链乘实例进行测试。

3. 分析算法的时间复杂度和空间复杂度。

4. 实验四:旅行商问题- 实验内容:使用遗传算法解决旅行商问题。

- 实验步骤:1. 设计遗传算法的参数,如种群大小、交叉率、变异率等。

2. 编写遗传算法的C++实现。

3. 使用标准测试数据集进行测试。

4. 分析算法的收敛速度和求解质量。

三、实验结果与分析1. 排序算法分析- 通过实验,我们验证了快速排序在平均情况下具有最佳的性能,其时间复杂度为O(nlogn),优于其他排序算法。

- 冒泡排序、选择排序和插入排序在数据规模较大时效率较低,不适合实际应用。

2. 背包问题- 贪心算法虽然简单,但在某些情况下无法得到最优解。

- 回溯法能够找到最优解,但计算量较大,时间复杂度较高。

- 分支限界法结合了贪心算法和回溯法的特点,能够在保证解质量的同时,降低计算量。

3. 矩阵链乘问题- 动态规划算法能够有效解决矩阵链乘问题,时间复杂度为O(n^3),空间复杂度为O(n^2)。

算法实验总结报告范文(3篇)

第1篇一、实验背景随着计算机科学的不断发展,算法在各个领域都扮演着至关重要的角色。

为了更好地理解和掌握算法设计与应用,我们进行了本次算法实验。

本次实验旨在通过实际操作,加深对常见算法的理解,提高算法设计与分析能力。

二、实验目的1. 掌握常见算法的基本原理和实现方法。

2. 熟悉算法的时间复杂度和空间复杂度分析。

3. 培养团队协作精神和实验操作能力。

三、实验内容本次实验主要涉及以下算法:1. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。

2. 查找算法:顺序查找、二分查找、斐波那契查找。

3. 图算法:深度优先搜索(DFS)、广度优先搜索(BFS)、最短路径算法(Dijkstra算法、Floyd算法)。

四、实验过程1. 熟悉实验环境,安装必要的开发工具和库。

2. 分析每个算法的基本原理,编写代码实现。

3. 对每个算法进行时间复杂度和空间复杂度分析。

4. 对比不同算法的优缺点,总结适用场景。

5. 编写实验报告,总结实验心得。

五、实验结果与分析1. 排序算法(1)冒泡排序:时间复杂度O(n^2),空间复杂度O(1),适用于小规模数据排序。

(2)选择排序:时间复杂度O(n^2),空间复杂度O(1),适用于小规模数据排序。

(3)插入排序:时间复杂度O(n^2),空间复杂度O(1),适用于部分有序数据排序。

(4)快速排序:时间复杂度O(nlogn),空间复杂度O(logn),适用于大规模数据排序。

(5)归并排序:时间复杂度O(nlogn),空间复杂度O(n),适用于大规模数据排序。

(6)堆排序:时间复杂度O(nlogn),空间复杂度O(1),适用于大规模数据排序。

2. 查找算法(1)顺序查找:时间复杂度O(n),空间复杂度O(1),适用于数据量较小的查找。

(2)二分查找:时间复杂度O(logn),空间复杂度O(1),适用于有序数据查找。

(3)斐波那契查找:时间复杂度O(logn),空间复杂度O(1),适用于有序数据查找。

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

《算法设计与分析》实验报告 实验六 概率算法 报告书 姓名 指导教师 学号 日 期 班级 实验内容 1) 使用随机方法求解圆周率。 2) 使用舍伍德算法求n个数中的第k大的数。 3) 试用拉斯维加斯方法求解8皇后问题,能得到正确解吗? 4) 蒙特卡罗算法有何特点?请举例说明。

实验目的

1)熟悉和掌握随机化方法 2)熟悉和掌握舍伍德算法、拉斯维加斯算法、蒙特卡罗算法以及它们的特点。

实验过程和步骤

1 使用随机方法求解圆周率 1.1 解题思路 假设正方形半径2r ,圆半径为r ,故圆的面积为π*r*r ,正方形面积为 r*r*4。 则通过蒙特卡洛算法,狂跑随机数,在正方形面积内抛骰子,若落在圆面积则计数。最后通过落院内的计数与总数比值,可以近似为圆面积与正方形面积的比值,之后再乘4,可得π。

1.2 程序运行情况 1.3 程序源码(含注释) #include using namespace std;

int n,r; double ans; void init() { //printf("input the num of the times, you want to rand(turned out to be the accuracy):\n"); //scanf("%d",&n); n=100000000; printf("input the range of the circle:\n"); scanf("%d",&r); printf("--------------------\n"); } bool inCircle(int x,int y) { if(x*x+y*y<=r*r)return true; return false; } //statistic = pi*r*r/(4*r*r) void getAns() { int sum=0; for(int i=0;i{ int x=rand()%(r+1); int y=rand()%(r+1); if(inCircle(x,y)) sum++; } ans=(double)sum/n*4; //概率 } void output() { printf("the ans of the pi is %lf\n",ans); } int main() { srand((unsigned)time(NULL)); init(); while(1)//疯狂计算 { getAns(); output(); } return 0; }

2 舍伍德算法求第k大的数 2.1 解题思路 其实就是普通的快速排序。排序中,讲基准数从第一个,改为跑随机数跑出来的骰子即可。 要处理的三个地方: 1. 快速排序要会写 2. 当前位置大于k则仅对前部分排序,当前位置大于k则仅对后部分排序,等于k则返回结果。 3. 要考虑递归时l==r时候,要加入判断机制。 2.2 测试样例 5 3 1 2 3 4 5 the ans is 3

5 3 2 6 1 3 5 the ans is 2

2.3 程序运行情况

2.4 程序源码(含注释) #include using namespace std; #define inf 999 int n,k; int ans;//答案下标 int e[inf];

void init() { printf("input the n: "); scanf("%d",&n); printf("input the k: "); scanf("%d",&k); printf("input the array: "); for(int i=0;iscanf("%d",&e[i]); printf("-----------\n"); k--;//因为下标自0始 } void SWD(int l,int r)//舍伍德版二分 { if(l==r)//终止条件,舍伍德的时候还特殊考虑一下 { if(l==k)ans=l; return; } int t=rand()%(r-l);//产生随机数 int pos=l+t;//舍伍德目标位置 int i=l; int j=r; while(i<=j) { while(i<=j&&e[j]>=e[pos])j--; while(i<=j&&e[i]<=e[pos])i++; if(i<=j) swap(e[i],e[j]); } swap(e[i],e[pos]); if(i==k)ans=i; else if(ielse SWD(l,i-1); } void output() { printf("the k th biggest num in the array is %d\n",e[ans]); } int main() { srand((unsigned)time(NULL)); init(); SWD(0,n-1); output(); return 0; }

3 拉斯维加斯方法求解8皇后问题 3.1 解题思路 网上的拉斯维加斯算法求8皇后是结合了随机算法与回溯的特点。我觉得有了回溯那还随机个球啊。所以我认为的拉斯维加斯算法是,随机一个8皇后的排布方案,然后进行检测,查看此方案是否是允许的八皇后棋盘,若不是则重新随机,否则输出结果。

3.2 程序运行情况

3.3 程序源码(含注释) #include using namespace std; int n,r; int queen[8]; double ans; void init() { printf("beginning the random queens:\n"); printf("--------------------\n"); } bool isLegal()//判断八皇后是否成立 { int i,j; for(i=0;i<8;i++)//行 for(j=i+1;j<8;j++) { int x1=i; int y1=queen[i]; int x2=j; int y2=queen[j]; if(x1==x2||y1==y2||abs(y2-y1)==abs(x2-x1))return false; } return true; } void LSWJS()//随机放皇后 { while(1) { for(int i=0;i<8;i++) queen[i]=rand()%8; if(isLegal())break; } } void output()//输出 { printf("get an ans!\n"); for(int i=0;i<8;i++) printf("%d ",queen[i]); printf("\n\n"); for(int i=0;i<8;i++) { for(int j=0;j<8;j++) if(queen[i]==j)printf("1 "); else printf("0 "); printf("\n"); } printf("\nDone!\n"); } int main() { srand((unsigned)time(NULL)); init(); LSWJS(); output(); return 0; }

4 蒙特卡罗算法有何特点 蒙特·卡罗方法,也称统计模拟方法,是二十世纪四十年代中期由于科学技术的发展和电子计算机的发明,而被提出的一种以概率统计理论为指导的一类非常重要的数值计算方法。是指使用随机数(或更常见的伪随机数)来解决很多计算问题的方法。与它对应的是确定性算法。 蒙特卡罗算法的特点——采样越多,越近似最优解。以及与采样数目有一定关系,以及是随机算法,故并不一定是最优解,但一定是可行解。 拉斯维加斯算法的特点——采样越多,越有机会找到最优解。

举例说明: 就比如第一题求圆周率。虽然说系统的随机数是伪随机数,但是我们也可以发现,使用蒙特卡洛算法出现了几个情况: 1)半径不能乱选,因为选择的半径是整数,随机数的选取也是整数,就会产生误差。我将半径设置为了RAND_MAX,程序的运算结果的精度一下就提高上来了。 2)随机采样的次数不能少,要大。因为随机次数少的话,随机带来的干扰太大,有效性实在太低了。 3)不管再怎么调整参数,随机性依然很大。我们可以看到每一次随机的结果都是不一样的,有差异。而这也是随机算法的特点所在。

相关文档
最新文档