计算机算法设计与分析实验报告大学论文
算法设计与分析实验报告三篇
算法设计与分析实验报告一实验名称统计数字问题评分实验日期2014 年11 月15 日指导教师姓名专业班级学号一.实验要求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'; }}五.程序调试中的问题调试过程,页码出现报错。
《算法设计与分析》实验报告实验一...
《算法设计与分析》实验报告实验一递归与分治策略应用基础学号:**************姓名:*************班级:*************日期:2014-2015学年第1学期第九周一、实验目的1、理解递归的概念和分治法的基本思想2、了解适用递归与分治策略的问题类型,并能设计相应的分治策略算法3、掌握递归与分治算法时间空间复杂度分析,以及问题复杂性分析方法二、实验内容任务:以下题目要求应用递归与分治策略设计解决方案,本次实验成绩按百分制计,完成各小题的得分如下,每小题要求算法描述准确且程序运行正确。
1、求n个元素的全排。
(30分)2、解决一个2k*2k的特殊棋牌上的L型骨牌覆盖问题。
(30分)3、设有n=2k个运动员要进行网球循环赛。
设计一个满足要求的比赛日程表。
(40分)提交结果:算法设计分析思路、源代码及其分析说明和测试运行报告。
三、设计分析四、算法描述及程序五、测试与分析六、实验总结与体会#include "iostream"using namespace std;#define N 100void Perm(int* list, int k, int m){if (k == m){for (int i=0; i<m; i++)cout << list[i] << " ";cout << endl;return;}else{for (int i=m; i<k; i++){swap(list[m], list[i]);Perm(list, k, m+1);swap(list[m], list[i]);}}}void swap(int a,int b){int temp;temp=a;a=b;b=temp;}int main(){int i,n;int a[N];cout<<"请输入排列数据总个数:";cin>>n;cout<<"请输入数据:";for(i=0;i<n;i++){cin>>a[i];}cout<<"该数据的全排列:"<<endl;Perm(a,n,0);return 0;}《算法设计与分析》实验报告实验二递归与分治策略应用提高学号:**************姓名:*************班级:*************日期:2014-2015学年第1学期一、实验目的1、深入理解递归的概念和分治法的基本思想2、正确使用递归与分治策略设计相应的问题的算法3、掌握递归与分治算法时间空间复杂度分析,以及问题复杂性分析方法二、实验内容任务:从以下题目中任选一题完成,要求应用递归与分治策略设计解决方案。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。
(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。
(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序,生成随机测试数据,测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。
(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。
- 分析贪心算法的正确性,并证明其最优性。
(3)实验步骤:- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性,并证明其最优性。
- 编写测试程序,验证贪心算法的正确性。
3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。
(2)实验内容:- 实现一个动态规划算法问题,如背包问题。
- 分析动态规划算法的正确性,并证明其最优性。
(3)实验步骤:- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性,并证明其最优性。
- 编写测试程序,验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。
算法分析与设计实验报告
算法分析与设计实验报告算法分析与设计实验报告一、引言算法是计算机科学的核心,它们是解决问题的有效工具。
算法分析与设计是计算机科学中的重要课题,通过对算法的分析与设计,我们可以优化计算机程序的效率,提高计算机系统的性能。
本实验报告旨在介绍算法分析与设计的基本概念和方法,并通过实验验证这些方法的有效性。
二、算法分析算法分析是评估算法性能的过程。
在实际应用中,我们常常需要比较不同算法的效率和资源消耗,以选择最适合的算法。
常用的算法分析方法包括时间复杂度和空间复杂度。
1. 时间复杂度时间复杂度衡量了算法执行所需的时间。
通常用大O表示法表示时间复杂度,表示算法的最坏情况下的运行时间。
常见的时间复杂度有O(1)、O(log n)、O(n)、O(n log n)和O(n^2)等。
其中,O(1)表示常数时间复杂度,O(log n)表示对数时间复杂度,O(n)表示线性时间复杂度,O(n log n)表示线性对数时间复杂度,O(n^2)表示平方时间复杂度。
2. 空间复杂度空间复杂度衡量了算法执行所需的存储空间。
通常用大O表示法表示空间复杂度,表示算法所需的额外存储空间。
常见的空间复杂度有O(1)、O(n)和O(n^2)等。
其中,O(1)表示常数空间复杂度,O(n)表示线性空间复杂度,O(n^2)表示平方空间复杂度。
三、算法设计算法设计是构思和实现算法的过程。
好的算法设计能够提高算法的效率和可靠性。
常用的算法设计方法包括贪心算法、动态规划、分治法和回溯法等。
1. 贪心算法贪心算法是一种简单而高效的算法设计方法。
它通过每一步选择局部最优解,最终得到全局最优解。
贪心算法的时间复杂度通常较低,但不能保证得到最优解。
2. 动态规划动态规划是一种将问题分解为子问题并以自底向上的方式求解的算法设计方法。
它通过保存子问题的解,避免重复计算,提高算法的效率。
动态规划适用于具有重叠子问题和最优子结构的问题。
3. 分治法分治法是一种将问题分解为更小规模的子问题并以递归的方式求解的算法设计方法。
算法设计与分析实验报告
算法设计与分析实验报告算法设计与分析实验报告引言:算法设计与分析是计算机科学中的重要课程,它旨在培养学生解决实际问题的能力。
本次实验旨在通过设计和分析不同类型的算法,加深对算法的理解,并探索其在实际应用中的效果。
一、实验背景算法是解决问题的步骤和方法的描述,是计算机程序的核心。
在本次实验中,我们将重点研究几种经典的算法,包括贪心算法、动态规划算法和分治算法。
通过对这些算法的设计和分析,我们可以更好地理解它们的原理和应用场景。
二、贪心算法贪心算法是一种基于局部最优选择的算法,它每一步都选择当前状态下的最优解,最终得到全局最优解。
在实验中,我们以背包问题为例,通过贪心算法求解背包能够装下的最大价值物品。
我们首先将物品按照单位重量的价值从大到小排序,然后依次将能够装入背包的物品放入,直到背包无法再装下物品为止。
三、动态规划算法动态规划算法是一种通过将问题分解为子问题,并记录子问题的解来求解整体问题的算法。
在实验中,我们以斐波那契数列为例,通过动态规划算法计算斐波那契数列的第n项。
我们定义一个数组来保存已经计算过的斐波那契数列的值,然后通过递推公式将前两项的值相加得到后一项的值,最终得到第n项的值。
四、分治算法分治算法是一种将问题分解为更小的子问题,并通过递归求解子问题的算法。
在实验中,我们以归并排序为例,通过分治算法对一个无序数组进行排序。
我们首先将数组分成两个子数组,然后对子数组进行递归排序,最后将两个有序的子数组合并成一个有序的数组。
五、实验结果与分析通过对以上三种算法的设计和分析,我们得到了以下实验结果。
在贪心算法中,我们发现该算法能够在有限的时间内得到一个近似最优解,但并不能保证一定得到全局最优解。
在动态规划算法中,我们发现该算法能够通过记忆化搜索的方式得到准确的结果,但在问题规模较大时,其时间复杂度较高。
在分治算法中,我们发现该算法能够将问题分解为更小的子问题,并通过递归求解子问题,最终得到整体问题的解。
算法设计与分析课程论文五篇范文
算法设计与分析课程论文五篇范文第一篇:算法设计与分析课程论文“卓越工程师教育培养计划”(简称卓越计划)旨在培养一批创新能力强、适应经济社会发展需要的高质量工程技术人才。
在南通大学计算机科学与技术学院制定的软件工程专业卓越工程师的培养计划中,算法设计与分析被设置为一门核心必修课程。
通过该门课程的系统授课,重点培养学生的计算机问题求解能力,该能力是软件工程专业学生成长为卓越工程师必备的一项核心竞争力。
一个典型的计算机问题的求解一般需要经历5个阶段:①问题的分析和建模;②算法设计方法和相应数据结构的选择;③算法的实现;④算法的正确性证明和复杂度分析;⑤算法实现的优化等。
经过多轮的教学实践发现,学生之间水平参差不齐是教学过程中面临的最大问题。
随着高校招生规模的不断增大,不同学生之间在基础知识、智力水平、兴趣爱好、学习动机和学习方法上存在较大的差异性。
相同的教学内容,对于一些基础较好的学生来说理解难度不大,但对于一些基础较弱的学生来说,则难以理解。
因此,如何尊重学生个性差异、发展学生个性特长,在考虑学生整体发展的同时兼顾学生的个性特长发展,从而最终提高各个层次学生的综合素质是算法设计与分析课程的教学改革实践中需要重点关注的问题。
通过多次与学生的深入交流发现,学生在这门课程的学习过程中面临如下问题:1)课程教学内容难度高。
课程需要学生掌握常见的算法设计策略,如分治法、动态规划法和贪婪法等,对设计出的算法能进行正确性证明和复杂度分析。
很多知识点抽象层次高,需要学生具备一定的数学分析能力,同时,通常算法内部逻辑比较复杂,因此需要学生具备较强的编程功底。
笔者在讲授这些知识点时,均假设学生具备一定的数学分析能力和编程基础,但实际情况却不容乐观,很多学生在大一和大二的时候并未重视相关课程的学习,很多知识点都已经还给授课老师,在课堂上需要花费一定时间帮助学生回忆这些知识点。
同时,部分学生因编程经验较为匾乏,难以顺利地将伪代码转化成可运行的程序代码。
计算机算法设计与分析实验报告
计算机算法设计与分析实验报告专业:java 技术学号:541213440245 姓名:徐亚涛指导老师:谷培培实验一:棋盘覆盖(递归与分治策略)一、实验目的与要求1、明确棋盘覆盖的概念2、明确递归与分治策略的设计思路。
3、利用递归与分治策略解决棋盘覆盖问题。
二、实验题:问题描述:递归与分治策略算法,用4种不同形态的L型骨牌覆盖一个给定的特殊棋盘上除特殊方格以外的所有方格,且任何2个L型骨牌不得重叠覆盖。
输入数据由程序运行后的界面中的编辑框中输入游戏规模,特殊方格的位置。
将覆盖的结果在窗口中显示出来。
三、实验代码package cn.ChessBoard;import java.awt.BorderLayout;import java.awt.Color;import java.awt.Font;import java.awt.GridLayout;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.util.Random;import javax.swing.JButton;import javax.swing.JFrame;import javax.swing.JLabel;import javax.swing.JPanel;import javax.swing.JTextArea;import javax.swing.JTextField;public class ChessBoards extends JFrame {private int tr, tc, dr, dc, size;//定义各成员变量int tile = 1;float red,green,blue;JPanel centerPanel;JPanel southPanel;JButton[][] button;JTextField TrText, TcText, DrText, DcText, SizeText;JLabel TrLabel, TcLabel, DrLabel, DcLabel, SizeLabel;JButton OKButton;JButton CancelButton;JPanel panel = new JPanel();public ChessBoards() {super();setTitle("棋盘覆盖");this.setResizable(false);centerPanel = new JPanel();southPanel = new JPanel();OKButton = new JButton("确定或开始");OKButton.addActionListener(new OKButtonAction()); CancelButton = new JButton("取消或清除"); CancelButton.addActionListener(new OKButtonAction()); setBounds(300, -10, 900, 900);//设置窗口大小与位置TrText = new JTextField("0",2);//定义各组件TcText = new JTextField("0",2);DrText = new JTextField("0",2);DcText = new JTextField("0",2);SizeText = new JTextField("4",2);TrLabel = new JLabel("起始方格坐标x: ");TcLabel = new JLabel("起始方格坐标y: "); DrLabel = new JLabel("特殊方格坐标x: "); DcLabel = new JLabel("特殊方格坐标y: "); SizeLabel = new JLabel("棋盘规模size: ");TrText.setEnabled(false);TcText.setEnabled(false);int tR = Integer.parseInt(TrText.getText());int tC = Integer.parseInt(TcText.getText());int dR = Integer.parseInt(DrText.getText());int dC = Integer.parseInt(DcText.getText());int Size = 1;for (int i=0;i<Integer.parseInt(SizeText.getText());i++) Size*=2;tr = tR;tc = tC;dr = dR;dc = dC;size = Size;southPanel.add(CancelButton);//添加各组件到窗体southPanel.add(TrLabel);southPanel.add(TrText);southPanel.add(TcLabel);southPanel.add(TcText);southPanel.add(DrLabel);southPanel.add(DrText);southPanel.add(DcLabel);southPanel.add(DcText);southPanel.add(SizeLabel);southPanel.add(SizeText);southPanel.add(OKButton);getContentPane().add(southPanel, BorderLayout.NORTH);setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}class gridLayout {public gridLayout() {centerPanel.setLayout(new GridLayout(0, size));button = new JButton[size][size];for (int i = 0; i < size; i++) {for (int j = 0; j < size; j++) {button[i][j] = new JButton();if (i == dr && j == dc) {button[i][j].setBackground(Color.BLUE);button[i][j].setText("<html><font size='2' color='white'>棋盘覆盖<br>Done By Java!</font></html>");button[i][j].setEnabled(false);}centerPanel.add(button[i][j]);}}}private void sleep(){for (int i=0;i<100;i++)for(int j=0;j<1000;j++);}public void ChessBoard(int tr, int tc, int dr, int dc, int size) {//算法实现if (size == 1) // 棋盘方格大小为1,说明递归到最里层return;int t = tile++;// 每次递增1Random rd = new Random();red=rd.nextFloat();green=rd.nextFloat();blue=rd.nextFloat();Color col = new Color(red,green,blue);sleep();int s = size / 2; // 棋盘中间的行、列号(相等的)// 检查特殊方块是否在左上角子棋盘中if (dr < tr + s && dc < tc + s) // 在ChessBoard(tr, tc, dr, dc, s);else // 不在,将该子棋盘右下角的方块视为特殊方块{button[tr + s - 1][tc + s - 1].setBackground(col);button[tr + s - 1][tc + s - 1].setEnabled(false);button[tr + s - 1][tc + s - 1].setText("<html><Font size='4',color='white'>"+t+"</Font></html>");ChessBoard(tr, tc, tr + s - 1, tc + s - 1, s);sleep();}// 检查特殊方块是否在右上角子棋盘中if (dr < tr + s && dc >= tc + s) // 在ChessBoard(tr, tc + s, dr, dc, s);else // 不在,将该子棋盘左下角的方块视为特殊方块{button[tr + s - 1][tc + s].setBackground(col);button[tr + s - 1][tc + s].setEnabled(false);button[tr + s - 1][tc + s ].setText("<html><Font size='4',color='white'>"+t+"</Font></html>");ChessBoard(tr, tc + s, tr + s - 1, tc + s, s);sleep();}// 检查特殊方块是否在左下角子棋盘中if (dr >= tr + s && dc < tc + s) // 在ChessBoard(tr + s, tc, dr, dc, s);else // 不在,将该子棋盘右上角的方块视为特殊方块{button[tr + s][tc + s - 1].setBackground(col);button[tr + s][tc + s - 1].setEnabled(false);button[tr + s ][tc + s - 1].setText("<html><Font size='4',color='white'>"+t+"</Font></html>");ChessBoard(tr + s, tc, tr + s, tc + s - 1, s);sleep();}// 检查特殊方块是否在右下角子棋盘中if (dr >= tr + s && dc >= tc + s) // 在ChessBoard(tr + s, tc + s, dr, dc, s);else // 不在,将该子棋盘左上角的方块视为特殊方块{button[tr + s][tc + s].setBackground(col);button[tr + s][tc + s].setEnabled(false);button[tr + s ][tc + s ].setText("<html><Font size='4',color='white'>"+t+"</Font></html>");ChessBoard(tr + s, tc + s, tr + s, tc + s, s);sleep();}}}public class OKButtonAction implements ActionListener {public void actionPerformed(ActionEvent e) {// TODO Auto-generated method stubJButton whichButton = (JButton) e.getSource();String whichName = whichButton.getActionCommand();if(whichName.equals("开始")) {getContentPane().add(centerPanel, BorderLayout.CENTER);int tR = Integer.parseInt(TrText.getText());int tC = Integer.parseInt(TcText.getText());int dR = Integer.parseInt(DrText.getText());int dC = Integer.parseInt(DcText.getText());int Size = 1;for (int i=0;i<Integer.parseInt(SizeText.getText());i++)Size*=2;tr = tR;tc = tC;dr = dR;dc = dC;size = Size;try {gridLayout grid = new gridLayout();grid.ChessBoard(tr, tc, dr, dc, size);centerPanel.updateUI();} catch (Exception EX) {EX.printStackTrace();}panel.removeAll();OKButton.setEnabled(false);}if (whichName.equals("取消或清除")) {//当你点下一个提示按钮时的事件响应JLabel label = new JLabel();label.setHorizontalAlignment(JLabel.CENTER);label.setText("<html><Font size='+8',color='red'><center><b><br> 您取消了操作或是<br><Font size='+8',color='blue'><center>您清除了前一个棋盘……" +"<br><Font size='+8',color='green'><center>下面是关于题目的介绍<br><br><br><br><br><br> </b></Font></html>");// JLabel l = new JLabel("题目要求");JTextArea area = new JTextArea("在一个2k x 2k 个方格组成的棋盘中,恰有一个方格与其他方格不同," +"称该方格为一特殊方格,且称该棋盘为一特殊棋盘。
计算机算法设计与分析小论文
计算机算法设计与分析小论文摘要:算法是一个系列解决问题的清晰指令;即在有限时间内能够对一定规范的输入;能够得到所需要的输出..如果一个算法本身是有缺陷的那么他往往不是这个问题的最佳解决方法;可见一个算法的优劣是通过一定的准则来规定的..通过这学期的对计算机算法分析设计这门课程的学习让我们充分的了解到了计算机算法的多样性和复杂性;让我们更加细心和耐心的去对待这门课程..例如甲某要去某个地方旅游;他有很多种方案到旅游地;但是不见的每种方案都是合理最优的这时就是需要考虑透过一定的算法来得到自己的最优路线..所以可见算法就是以最少的成本、最快的速度、最好的质量开发出合适各种各样应用需求的软件;必须遵循软件工程的原则;设计出高效率的程序..一个高效的程序不仅需要编程技巧;更需要合理的数据组织和清晰高效的算法..目前我们将进行常见的算法分析设计策略介绍:1.递归算法1.1递归算法介绍:直接或间接的调用自身的算法称为递归算法..或者说就是用自己来定义自己;不断调用自己的某一种状态..1.2递归算法满足的条件1递归满足2个条件:1有反复执行的过程调用自身2有跳出反复执行过程的条件递归出口1.3递归例子递归例子:阶乘问题n = n n-1 n-2 ... 1n>0//阶乘int resultint i{int sum = 0;if 0 == ireturn 1;elsesum = i resulti-1;return sum;}可见一个递归算法都有一个比较特殊的特点;那就是要先处理一些比较特殊的情况再处理递归关系..如上例中如果是0的话那么他的阶乘就是1;所以先处理0这个特殊情况;然后再调用其他的递归关系得到自己想要的阶乘..比如当我们想要求出4的结果那么我们就需要调用result3的结果而result3又要调用result2的结果就这样直到得出答案为止..在我们日常;递归算法的出现可以帮助我们解决很多问题;正因为它的:结构清晰;可读性强;而且容易用数学归纳法来证明算法的正确性;因此它为设计算法、调试程序带来很大方便..2.分治算法2.1分治算法介绍:一个分治算法把问题实例划分成若干子实例多数情况是分成两个;并分别递归地解决每个子实例;然后把这些子实例的解组合起来;得到原问题实例的解..2.2 分治算法的特性1)规模小;则很容易解决2大问题可以分为若干规模小的相同问题3利用子问题的解可以合并成该问题的解2.3分治算法的遇到问题为了阐明这个方法;考虑这样一问题:在一个整数组A1...n中;同时寻找最大值和最小值..下面我们来看一下用分治策略:将数组分割成两半;A1...n/2和An/2+1...n;在每一半中找到最大值和最小值;并返回这两个最小值中的最小值及这两个最大值中的最大值..if high-low=1 thenif Alow<Ahigh then return Alow;Ahigh;elsereturn Ahigh;Alow;end ifelsemid==low+high/2;x1==minlow;mid;y1==maxlow;mid;x2==minmid+1;high;y2==minmid+1;high;x==minx1;x2y==maxy1;y2return x;yend if可见当我们在一个数组中如何同时选择最大最小值时;分治算法时一个不错当选择..如上例中所示;我们把一个数组分成了low部分和high部分两个较小当部分;然后求出他们的mid..用low high部分分别和mid比较把其最大最小值进行存放;最后再比较存放数当最大最小值..我们考虑的例子中只考虑了时2的幂的情况..而且分成的子问题都是相互独立的; 如果子问题不独立而是出现重复子问题那往往我们选择的不是分治算法而是采用动态规划算法求解更加便利..3.动态规划:3.1动态规划介绍动态规划算法;就是递推+重复子问题..该算法效率主要与重复子问题的处理有关..动态规划算法与分治法类似;其基本思想也是将待求解问题分解成若干个子问题;先求解子问题;然后从这些子问题的解得到原问题的解..与分治法不同的是;适合于用动态规划求解的问题;经分解得到子问题往往不是互相独立的.典型的题目有陪审团、最大公共子串问题;流水作业调度;矩阵乘法背包问题和0-1背包问题3.2动态规划介绍例子例:最大公共子串问题这个是动态规划的基础题目..这个问题;不妨设第一个串为a;长度为n;第二个串为b;长度m..那么最长的子序列长度为fn;m当an=am时 fn;m=1+fn-1;m-1否则fn;m=maxfn-1;fm-1同时建立一个存储计算过的fx;y的矩阵;如果计算过了就直接使用..2.对已集装箱问题中的背包问题和0-1背包问题的区别..背包问题可以将一个整体进行拆分存放;而0-1背包问题必须存放的是一个整体直到出现最大价值为之..比如当c=50 而我这有三个小箱a.b.c重量分别是10 .20.30而价值分别对应60.100.120这时当我们考虑装箱时用背包问题的思想;不管是背包还是0-1背包都要体现价值最大化..在这使用背包问题这价值为60+100+80分别是装了a;b;和c的20重量当我们考虑用0-1背包时最大价值为100+120分别装了b;c..这就是两者最大价值的实现和不同点..4.贪心算法:是指在对问题求解时;总是做出在当前看来是最好的选择..也就是说;不从整体最优上加以考虑;他所做出的仅是在某种意义上的局部最优解.. 该算法的应用:最小生成树;最短路径;哈夫曼编码活动时间安排的问题设有N个活动时间集合;每个活动都要使用同一个资源;比如说会议场;而且同一时间内只能有一个活动使用;每个活动都有一个使用活动的开始si和结束时间fi;即他的使用区间为si;fi;现在要求你分配活动占用时间表;即哪些活动占用该会议室;哪些不占用;使得他们不冲突;要求是尽可能多的使参加的活动最大化;即所占时间区间最大化1.include <iostream>ing namespace std;3.4.void GreedyChoose int len;int s;int f;bool flag;5.6.int main int argc; char argv7.{8.int s11 ={1;3;0;5;3;5;6;8;8;2;12};9.int f11 ={4;5;6;7;8;9;10;11;12;13;14};10.11.bool mark11 = {0};12.13. GreedyChoose11;s;f;mark;14.for int i=0;i<11;i++15.if marki16. cout<<i<<" ";17. system"pause";18.return 0;19.}20.21.void GreedyChoose int len;int s;int f;bool flag22.{23. flag0 = true;24.int j = 0;25.for int i=1;i<len;++i26.if si >= fj27. {28. flagi = true;29. j = i;30. }31.}得出结果是 0 3 7 10;也就是对应的时间段本次课程的心得体会:计算机软件专业中;算法分析与设计是一门非常重要的课程;很多人为它如痴如醉..很多问题的解决;程序的编写都要依赖它;在软件还是面向过程的阶段;就有程序=算法+数据结构这个公式..算法的学习对于培养一个人的逻辑思维能力是有极大帮助的;它可以培养我们养成思考分析问题;解决问题的能力..如果一个算法有缺陷;或不适合某个问题;执行这个算法将不会解决这个问题..不同的算法可能用不同的时间、空间或效率来完成同样的任务..一个算法的优劣可以用空间复杂性和时间复杂度来衡量..算法可以使用自然语言、伪代码、流程图等多种不同的方法来描述..计算机系统中的操作系统、语言编译系统、数据库管理系统以及各种各样的计算机应用系统中的软件;都必须使用具体的算法来实现..算法设计与分析是计算机科学与技术的一个核心问题..因此;学习算法无疑会增强自己的竞争力;提高自己的修为;为自己增彩..学习算法分析与设计使我对软件基础知识中算法的地位有了充分的了解;认识到光书本的知识的确不行;还是要理论联系实践才行..因此不断的练习是必要的;上机实践更重要虽然课程结束了;但我依然还会继续学习算法分析与设计;以后我将充分利用所学到我实际的开发项目中..。
计算机算法设计与分析实验报告
int turn = scale - 1;//需要走的趟数
for (int i = 0; i < turn; i++) {
int max = 0; //记录选取最大值的下脚标
int len = scale - i;//依然无序的元素长度
for (int j = 1; j < len; j++) {
temp[k++] = array[i++];
} else {
temp[k++] = array[j++];
}
}
}
for (i = low, k = 0; k < temp.length; k++) {
array[i++] = temp[k];
}
}
* @Title: shellSort
* @Description:希尔排序,对插入排序的高级优化
3、要求在main()函数中调用以上函数,并输出各排序算法所用时间。
二、实验环境(本实验所使用的硬件设备和相关软件)
计算机一台
Java运行环境
三、实验内
* @Description:几种常见的排序算法
* @author 1639469539@
if (array[max] < array[j]) {//比较找出最大值的下脚标
max = j;
}
}
if (max != len - 1) {//需要交换的时候
swap(array, max, len - 1);
}
}
计算机算法与设计分析实验报告大学论文
计算机算法与设计分析实验报告班级:姓名:学号:实验一分治与递归一、实验目的与要求1、熟悉C/C++语言的集成开发环境;2、通过本实验加深对递归过程的理解二、实验题:任意输入一个整数,输出结果能够用递归方法实现整数的划分。
三、程序代码四、实验结果一、实验目的与要求1、熟悉二分搜索算法;2、初步掌握分治算法;二、实验题设a[0:n-1]是一个已排好序的数组。
请改写二分搜索算法,使得当搜索元素x不在数组中时,返回小于x的最大元素的位置I和大于x的最大元素位置j。
当搜索元素在数组中时,I和j相同,均为x在数组中的位置。
三、程序代码四、实验结果实验二动态规划算法一、实验目的与要求1、熟悉最长公共子序列问题的算法;2、初步掌握动态规划算法;二、实验题若给定序列X={x1,x2,…,xm},则另一序列Z={z1,z2,…,zk},是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有:zj=xij。
例如,序列Z={B,C,D,B}是序列X={A,B,C,B,D,A,B}的子序列,相应的递增下标序列为{2,3,5,7}。
给定2个序列X和Y,当另一序列Z既是X的子序列又是Y的子序列时,称Z是序列X和Y的公共子序列。
三、程序代码四、实验结果一、实验目的与要求1、熟悉最长最大字段和问题的算法;2、进一步掌握动态规划算法;二、实验题若给定n个整数组成的序列a1,a2,a3,……a n,求该序列形如a i+a i+1+……+a n的最大值。
三、程序代码四、实验结果实验三贪心算法一、实验目的与要求1、初步掌握贪心算法2、熟悉多机调度问题的算法;二、实验题要求给出一种作业调度方案,使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
约定,每个作业均可在任何一台机器上加工处理,但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、程序代码四、实验结果一、实验目的与要求1、熟悉贪心算法的基本原理与适用范围。
算法分析与设计实验报告
算法分析与设计实验报告1. 引言算法是计算机科学中的核心概念之一,它为解决问题提供了一种清晰、有效的方法。
本实验报告旨在通过分析与设计一个特定算法的实验过程,来加深对算法的理解和应用。
2. 实验背景在现代社会中,算法的应用无处不在。
无论是搜索引擎的排序算法,还是社交媒体的推荐算法,都离不开算法的支持。
因此,学习算法的分析与设计,对于计算机科学相关领域的学生来说具有重要的意义。
3. 实验目的本实验的主要目的是通过分析与设计一个特定算法,加深对算法的理解和应用。
通过实际操作,学生将能够熟悉算法的设计过程,并能够分析算法的效率和复杂性。
4. 实验步骤4.1 确定算法目标在开始实验之前,我们需要明确算法的目标。
在本实验中,我们将设计一个排序算法,用于对一组数字进行排序。
4.2 了解算法原理在设计算法之前,我们需要对目标算法的原理进行深入了解。
在本实验中,我们将选择经典的冒泡排序算法作为实现对象。
冒泡排序算法的基本思想是通过比较相邻的元素,并根据需要交换位置,使得每一轮循环都能使最大(或最小)的元素“冒泡”到数组的末尾。
通过多次迭代,最终实现整个数组的排序。
4.3 实现算法在了解算法原理后,我们将根据算法的步骤逐步实现。
具体步骤如下:1.遍历待排序数组,从第一个元素开始。
2.比较当前元素与下一个元素的大小。
3.如果当前元素大于下一个元素,则交换它们的位置。
4.继续比较下一个元素,直到遍历完整个数组。
5.重复上述步骤,直到没有需要交换的元素。
4.4 测试算法在实现算法之后,我们需要对其进行测试,以验证其正确性和效率。
我们可以准备一组随机的数字作为输入,并对算法进行测试。
通过比较输入和输出结果,我们可以判断算法是否正确。
同时,我们还可以通过计算算法的时间复杂性和空间复杂性来评估其效率。
在本实验中,我们将使用时间复杂性分析来评估算法的效率。
4.5 分析与总结通过测试和分析,我们将得出算法的执行时间和空间复杂性。
《算法设计与分析》课程实验报告 (算法问题求解基础1)
}
int s2[10] = {0,9,189,2889,38889,488889,5888889,68888889,788888889};
int a;
scanf("%d",&a);
int count;
count = 0;
while(a > 0){
题目二:最大间隙
源码:
#include<iostream>
#include<cstdio>
using namespace std;
double a[10000] = {0};
int main(){
int n;
cin>>n;
for(int i = 0 ; i < n ; i++){
cin>>a[i];
样例输出:
3.2
二、实验目的
(1)理解算法的概念
(2)理解函数渐近态的概念和表示方法
(3)初步掌握算法时间复杂度的计算方法
三、实验要求
(1)对于每个题目提交实验代码。
(2)根据程序设计测试数据,并记录测试结果,要求边界情况必须测试
(3)使用我们学过的分析方法分析你的算法的时间效率,如果可能,请进行算法的优化,尽量减小算法的时间效率或空间效率。
《算法设计与分析》课程实验报告
实验序号:1 实验项目名称:算法问题求解基础
一、实验题目
题目一:统计数字问题
题目描述
一本书的页码从自然数1开始顺序编码直到自然数n。输的页码按照通常的习惯编排,每个页码都不含有多余的前导数字0.例如,第6页用数字6表示,而不是06或者006等。数字计数问题要求对给定书的总页码n,计算出书的全部页码中分别用到多少次数字0,1,2...8,9。
算法设计与分析实验报告_2
课程设计报告题目:计算机算法基础实验报告课程名称:专业班级:学号:姓名:指导教师:报告日期:计算机科学与技术学院目录一、实验目的 (3)二、实验题目 (3)三、设计分析 (3)1.生成最短路径问题设计分析 (3)2.最优二分检索树问题设计分析 (4)四、算法描述 (5)1.生成最短路径问题算法描述(用流程图表示) (5)2.最优二分检索树问题算法描述(用流程图表示) (6)五、程序 (7)1. 生成最短路径问题算法代码 (7)2.最优二叉检索树源代码 (10)六、测试与分析 (13)1.生成最短路径问题算法 (13)2.最优二叉检索树源测试及分析 (15)七、实验总结及体会 (16)八、参考书目 (17)一、实验目的1.掌握贪心方法、动态规划的基本思想2.了解适用贪心方法、动态规划的问题类型,并能设计相应的贪心法算法3.掌握贪心算法、动态规划算法时间空间复杂度分析,以及问题复杂性分析方法二、实验题目1.实现单源点生成最短路径的贪心方法,完善算法,求出长度,并推导路径上的结点序列2.实现最优二分检索树算法,计算各C(i,j)、R(i,j)、W(i,j)的值,并推导树的形态三、设计分析1.生成最短路径问题设计分析为了制定产生最短路径贪心算法,对于这个问题需要想出一个多级解决方案和最优的量度标准。
方法之一是逐条构造这些最短路径,可以用迄今已经生成的所有路径长度之和作为一种量度,为了使这一量度达到最小,其单独的每一个路径都必须具有最小长度。
使用这一个量度标准时,假定已经构造了i条最短路径,则下面要构造的路径应该是下一个最小的长度路径。
生成从源点v0到所有其他结点的最短路径的贪心方法就是按照路径长度的非降次序生成这些路径。
首先,生成一条到最短结点的最短路径,然后生成一条到第二近结点的最短路径,依次往下进行…。
为了按照这样的路径生成这些最短路径,需要确定与其生成最短路径的下一个结点,以及到这一结点的最短路径。
算法设计与分析 实验报告
算法设计与分析实验报告1. 引言本实验报告旨在介绍算法设计与分析的相关内容。
首先,我们将介绍算法设计的基本原则和步骤。
然后,我们将详细讨论算法分析的方法和技巧。
最后,我们将通过一个实例来演示算法设计与分析的过程。
2. 算法设计算法设计是解决问题的关键步骤之一。
它涉及确定问题的输入和输出,以及找到解决方案的具体步骤。
以下是算法设计的一般步骤:2.1 理解问题首先,我们需要全面理解给定问题的要求和约束。
这包括确定输入和输出的格式,以及问题的具体要求。
2.2 制定算法思路在理解问题后,我们需要制定解决问题的算法思路。
这涉及确定解决问题的高层次策略和步骤。
通常,我们使用流程图、伪代码等工具来表示算法思路。
2.3 编写算法代码在制定算法思路后,我们可以根据思路编写实际的算法代码。
这可能涉及选择适当的数据结构和算法,以及编写相应的代码来实现解决方案。
2.4 调试和测试编写算法代码后,我们需要进行调试和测试,以确保算法的正确性和可靠性。
这包括检查代码中可能存在的错误,并使用不同的测试样例来验证算法的正确性。
3. 算法分析算法分析是评估算法性能的过程。
它涉及确定算法的时间复杂度和空间复杂度,以及评估算法在不同输入情况下的执行效率。
3.1 时间复杂度时间复杂度是衡量算法执行时间随输入规模增长的速度。
常见的时间复杂度包括常数时间复杂度 O(1)、线性时间复杂度 O(n)、对数时间复杂度 O(log n)、平方时间复杂度 O(n^2) 等。
通过分析算法中的循环、递归等关键部分,可以确定算法的时间复杂度。
3.2 空间复杂度空间复杂度是衡量算法所需空间随输入规模增长的速度。
它通常用于评估算法对内存的使用情况。
常见的空间复杂度包括常数空间复杂度 O(1)、线性空间复杂度 O(n)、对数空间复杂度 O(log n) 等。
通过分析算法中的变量、数组、递归栈等关键部分,可以确定算法的空间复杂度。
3.3 执行效率评估除了时间复杂度和空间复杂度外,我们还可以通过实验和测试来评估算法的执行效率。
算法论文
计算机算法设计与分析结课论文与实验总结班级:网络1201姓名:***学号:************辅导老师:***对于计算机科学来说,算法(Algorithm)的概念是至关重要的。
算法是一系列解决问题的清晰指令,也就是说,能够对一定规范的输入,在有限时间内获得所要求的输出。
如果一个算法有缺陷,或不适合于某个问题,执行这个算法将不会解决这个问题。
不同的算法可能用不同的时间、空间或效率来完成同样的任务。
一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。
或者看成按照要求设计好的有限的确切的计算序列,并且这样的步骤和序列可以解决一类问题。
算法可以使用自然语言、伪代码、流程图等多种不同的方法来描述。
一个算法应该具有以下五个重要的特征:1)有穷性:一个算法必须保证执行有限步之后结束;2)确切性:算法的每一步骤必须有确切的定义;3)输入:一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定除了初始条件;4)输出:一个算法有一个或多个输出,以反映对输入数据加工后的结果。
没有输出的算法是毫无意义的;5)可行性:算法原则上能够精确地运行,而且人们用笔和纸做有限次运算后即可完成。
一、算法复杂性分析的方法介绍1.1算法的复杂性是算法效率的度量,是评价算法优劣的重要依据。
一个算法的复杂性的高低体现在运行该算法所需要的计算机资源的多少上面,所需的资源多,我们就说该算法的复杂性越高;反之,所需的资源越低,则该算法的复杂性越低。
计算机的资源,最重要的是时间和空间(即存储器)资源。
因而,算法的复杂性有时间复杂性和空间复杂性之分。
不言而喻,对于任意给定的问题,设计出复杂性尽可能地的算法是我们在设计算法是追求的一个重要目标;另一方面,当给定的问题已有多种算法时,选择其中复杂性最低者,是我们在选用算法适应遵循的一个重要准则。
因此,算法的复杂性分析对算法的设计或选用有着重要的指导意义和实用价值。
算法设计与分析学习报告(优秀范文5篇)
算法设计与分析学习报告(优秀范文5篇)第一篇:算法设计与分析学习报告算法课程学习报告持续13周的高级算法设计与分析课程结束了。
选修了这门课程的同学们即将迎来最后的考试。
回顾这半年以来关于这么课程的学习情况,我体会最深的是:不论是从深度还是从广度上,现在所习的算法比曾经学习的算法难度增加了很多。
但是邓教授极富经验的教学和详细的课件,为我的学习提供了很大的方便。
可是毕竟我以前的底子不够厚,基础不够劳,在听课中会出现跟不上教师思路的现象。
我也积极的采取措施,争取处理好这种情况。
总体说来,上完算法课,我还是学到了很多东西的。
下面我就对所学的内容进行梳理归纳,总结一下我在学习中的体会和研究心得。
算法课程的开课阶段,邓教授为我们简单介绍了算法,课堂上可能用到的参考资料,以及一些著名的算法方面的书籍,为我的学习提供潜在的工具。
我购买了一本教材——《算法导论》。
这本书够厚,够详细。
但是我一直没有机会仔细的研读。
我想有一天希望能够好好读一下。
在介绍算法的课堂上,我还了解了算法相关的一些基本概念,算法的重要性,还有算法的历史。
我印象最深的就是一个叫图灵的外国人。
对计算机科学与技术这个领域做出了图书贡献。
我个人认为,堪比爱因斯塔发现相对论的贡献。
都揭示了某个领域的本质。
开辟的一个领域的发展。
对于整个人类来说,他们这类人都是功不可没的。
已经不能简单的用伟人来形容他们。
但是人类社会需要这样的人,社会需要一些人的推动才能进步。
说到这里,我不禁要想,算法到底有什么用,也许答案是简单的,为了方便写程序实现系统功能。
这只是表面的用途。
我觉得最本质的作用是为了社会进步。
辩证唯物主义自然观中有关于科学技术的详细定义。
之所以产生科学技术是为了发挥人的主观能动性去改造自然。
学习和研究算法正是为了让人在一定的限度内改造自然。
我不是在扯,而是在写算法报告和背自然辩证法资料的时候产生的心得体会,不知道算不算邓教授要求的心得。
介绍完算法历史以后,就进入的真正的算法设计与分析的学习。
算法设计与分析实验报告
算法设计与分析实验报告1. 引言本实验旨在设计和分析一个算法,解决特定的问题。
通过对算法的设计、实现和性能分析,可以对算法的优劣进行评估和比较。
本报告将按照以下步骤进行展开:1.问题描述2.算法设计3.算法实现4.性能分析5.结果讨论和总结2. 问题描述在本实验中,我们面临的问题是如何在一个给定的无序数组中寻找一个特定元素的位置。
具体而言,给定一个包含n个元素的数组A和一个目标元素target,我们的目标是找到target在数组A中的位置,如果target不存在于数组中,则返回-1。
3. 算法设计为了解决上述问题,我们设计了一个简单的线性搜索算法。
该算法的思想是从数组的第一个元素开始,逐个比较数组中的元素与目标元素的值,直到找到匹配的元素或搜索到最后一个元素。
算法的伪代码如下:function linear_search(A, target):for i from 0 to len(A)-1:if A[i] == target:return ireturn -14. 算法实现我们使用Python编程语言实现了上述线性搜索算法。
以下是算法的实现代码:def linear_search(A, target):for i in range(len(A)):if A[i] == target:return ireturn-15. 性能分析为了评估我们的算法的性能,我们进行了一系列实验。
我们使用不同大小的数组和不同目标元素进行测试,并记录了每次搜索的时间。
实验结果显示,线性搜索算法的时间复杂度为O(n),其中n是数组的大小。
这是因为在最坏的情况下,我们需要遍历整个数组才能找到目标元素。
6. 结果讨论和总结通过对算法的设计、实现和性能分析,我们可以得出以下结论:1.线性搜索算法是一种简单但有效的算法,适用于小规模的数据集。
2.线性搜索算法的时间复杂度为O(n),在处理大规模数据时可能效率较低。
3.在实际应用中,我们可以根据具体的问题和数据特征选择合适的搜索算法,以提高搜索效率。
计算机算法设计与分析实验报告
计算机算法设计与分析实验报告专业:软件技术学号:************姓名:覃立煜指导老师:***实验一:最长公共子序列问题一、实验目的与要求1、明确子序列公共子序列的概念2、最长公共子序列(Longest Common Subsequence,简称LCS) 的概念3、利用动态规划解决最长公共子序列问题二、实验题:问题描述:字符序列的子序列是指从给定字符序列中随意地(不一定连续)去掉若干个字符(可能一个也不去掉)后所形成的字符序列。
令给定的字符序列X=“x0,x1,…,x m-1”,序列Y=“y0,y1,…,y k-1”是X的子序列,存在X的一个严格递增下标序列<i0,i1,…,i k-1>,使得对所有的j=0,1,…,k-1,有x ij=y j。
例如,X=“ABCBDAB”,Y=“BCDB”是X的一个子序列。
给定两个序列A和B,称序列Z是A和B的公共子序列,是指Z同是A和B的子序列。
问题要求已知两序列A和B的最长公共子序列。
三、实验代码#include<stdlib.h>#include<stdio.h>#include<string.h>#define Size 100void LCSLength(int m,int n,char *x,char *y,int c[Size][Size],int b[Size][Size]){ int i,j;for(i=1;i<=m+1;i++) c[i][0]=0;for(i=1;i<=n+1;i++) c[0][i]=0;for(i=1;i<=m+1;i++)for(j=1;j<=n+1;j++){ if(x[i]==y[j]){ c[i][j]=c[i-1][j-1]+1; b[i][j]=0; }else if(c[i-1][j]>=c[i][j-1]){ c[i][j]=c[i-1][j];b[i][j]=1; }else { c[i][j]=c[i][j-1];b[i][j]=2; }}}void LCS(int i,int j,char *x,int b[Size][Size]){ if(i==0||j==0) return;if(b[i][j]==0){ LCS(i-1,j-1,x,b);printf("%c",x[i]); }else if(b[i][j]==1) LCS(i-1,j,x,b);else LCS(i,j-1,x,b);}main(){ int m,n,i;int c[Size][Size],b[Size][Size];char x[Size],y[Size];printf("输入序列x的长度(小于100):");scanf("%d",&m);printf("输入序列y的长度(小于100):");scanf("%d",&n);i=1;printf("输入x的成员(不用空格,直接输入字符串):\n");while(i<m+2){ scanf("%c",&x[i]);if(x[i]!='\0') i++;}i=1;printf("输入y的成员(不用空格,直接输入字符串):\n");while(i<n+2){ scanf("%c",&y[i]);if(y[i]!='\0') i++;}LCSLength(m,n,x,y,c,b);printf("最长公共子序列:\n");LCS(m+1,n+1,x,b);printf("\n"); }四、实验结果实验二:0-1背包问题一、实验目的与要求1、明确0-1背包问题的概念2、利用动态规划解决0-1背包问题问题二、实验题:0-1背包问题(knapsack problem),某商店有n个物品,第i个物品价值为vi,重量(或称权值)为wi,其中vi和wi为非负数, 背包的容量为W,W为一非负数。
算法设计与分析 实验报告
算法设计与分析实验报告算法设计与分析实验报告一、引言在计算机科学领域,算法设计与分析是非常重要的研究方向。
本次实验旨在通过实际案例,探讨算法设计与分析的方法和技巧,并验证其在实际问题中的应用效果。
二、问题描述本次实验的问题是求解一个整数序列中的最大子序列和。
给定一个长度为n的整数序列,我们需要找到一个连续的子序列,使得其和最大。
三、算法设计为了解决这个问题,我们设计了两种算法:暴力法和动态规划法。
1. 暴力法暴力法是一种朴素的解决方法。
它通过枚举所有可能的子序列,并计算它们的和,最终找到最大的子序列和。
然而,由于需要枚举所有子序列,该算法的时间复杂度为O(n^3),在处理大规模数据时效率较低。
2. 动态规划法动态规划法是一种高效的解决方法。
它通过定义一个状态转移方程,利用已计算的结果来计算当前状态的值。
对于本问题,我们定义一个一维数组dp,其中dp[i]表示以第i个元素结尾的最大子序列和。
通过遍历整个序列,我们可以利用状态转移方程dp[i] = max(dp[i-1]+nums[i], nums[i])来计算dp数组的值。
最后,我们返回dp数组中的最大值即为所求的最大子序列和。
该算法的时间复杂度为O(n),效率较高。
四、实验结果与分析我们使用Python编程语言实现了以上两种算法,并在相同的测试数据集上进行了实验。
1. 实验设置我们随机生成了1000个整数作为测试数据集,其中包含正数、负数和零。
为了验证算法的正确性,我们手动计算了测试数据集中的最大子序列和。
2. 实验结果通过对比实验结果,我们发现两种算法得到的最大子序列和是一致的,验证了算法的正确性。
同时,我们还对两种算法的运行时间进行了比较。
结果显示,暴力法的运行时间明显长于动态规划法,进一步证明了动态规划法的高效性。
五、实验总结通过本次实验,我们深入了解了算法设计与分析的方法和技巧,并通过实际案例验证了其在解决实际问题中的应用效果。
我们发现,合理选择算法设计方法可以提高算法的效率,从而更好地解决实际问题。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
华北电力大学实验报告||实验名称算法设计实验课程名称算法设计与分析||专业班级:信安1301 学生姓名:学号:成绩:指导教师:胡朝举实验日期: 2015年11月设两个有序表存放在同一数组中相邻的位置上:R[low..mid]和R[mid+1..high],每次分被从两个表中取出一个记录进行关键字的比较,将较小者放入T[low..high]中,重复此过程,直至其中一个表为空,最后将另一非空表中余下的部分直接复制到T中。
三、实验结果四、算法分析1)时间复杂度当有n个记录时,需进行[log2n]趟归并排序,每一趟归并,其关键字比较次数不超过n,元素移动次数都是n,因此,归并排序的时间复杂度为O(nlog2n)。
2)空间复杂度用顺序表实现归并排序时,需要和待排序记录个数相等的辅助存储空间,所以空间复杂度为O(n);五、实验代码#include<iostream.h>#include<algorithm>#include<time.h>#include<stdio.h>#include<stdlib.h>using namespace std;template<class Type>void MergSort(Type a[], int n){Type *b = new Type[n];int s = 1;while (s < n){MergPass(a, b, s, n);s += s;MergPass(b, a, s, n);s += s;}}template<class Type>void MergPass(Type x[], Type y[], int s, int n){int i = 0;while (i <= n - 2 * s){Merg(x, y, i, i + s - 1, i + 2 * s - 1);i = i + 2 * s;}if (i + s < n)这个过程概括的说就是一个根据频率建立二叉树的过程。
建完之后对应的编码也就完成了。
第一步a. 这个a就和之前的活动选择问题一样,把需要的所以字符按照频率排序。
第三部c. 其实和第二部雷同,就是一个循环的过程。
这里再次去除队列中的最小频率的两项(这时是c和b)。
组成新的节点加入队列排序。
如此循环往复,最后就形成了(f)这个二叉树。
现在有了二叉树只有,我们把左子树这条边标记为0,右子树标记为1。
这样就差生了对应的编码方式a=0; b=101;....三、实验结果四、算法分析五、实验代码#include<iostream>#include<string>#include<vector>#include<algorithm>#include<fstream>using namespace std;struct Node{char Content;float Frequency;Node*Left;Node*Right;Node*Parent;string Code;//编码串char LOR;//该节点作为左孩子(0)还是右孩子(1)};bool Compare(Node*a,Node*b){return a->Frequency>b->Frequency;}class HuffmanCode{public:vector<Node*>Show;//显示结果的向量//输入文件绝对路径HuffmanCode(char*file);~HuffmanCode();void Executing();private:char*FilePath;Node*Root;//哈夫曼树根节点vector<Node*>AsQueue;//作为队列的向量//读取文件内容,扫描字符出现频率,形成初始队列void ReadAndScan();//生成哈夫曼树void CreateHuffmanTree();//设置编码void ErgodicTree();//释放节点void Delete(Node*n);};HuffmanCode::HuffmanCode(char*file){FilePath=file;}HuffmanCode::~HuffmanCode(){//释放节点Delete(Root);}void HuffmanCode::Executing(){//读取文件内容,扫描字符出现频率,形成初始队列ReadAndScan();//生成哈夫曼树CreateHuffmanTree();//遍历整棵树并设置编码ErgodicTree();}//读取文件内容,扫描字符出现频率,形成初始队列void HuffmanCode::ReadAndScan(){ ifstream fin;fin.open("E:\\h.dat",ios::binary);string str;fin>>str;fin.close();bool used;int temp1,temp2;temp1=str.length();for(int i=0;i<temp1;i++){used=false;temp2=AsQueue.size();for(int j=0;j<temp2;j++){if(AsQueue[j]->Content==str[i]){AsQueue[j]->Frequency++;used=true;break;}}if(!used){Node*n=new Node();n->Content=str[i];n->Frequency=1;n->Left=NULL;n->Right=NULL;AsQueue.push_back(n);}}sort(AsQueue.begin(),AsQueue.end(),Compare); temp2=AsQueue.size();for(int i=0;i<temp2;i++){Show.push_back(AsQueue[i]);}}//生成哈夫曼树void HuffmanCode::CreateHuffmanTree(){ while(AsQueue.size()!=1){int s=AsQueue.size()-1;Node*n=new Node();n->Frequency=AsQueue[s]->Frequency+AsQueue[s-1]->Frequency; n->Left=AsQueue[s];AsQueue[s]->LOR='0';n->Right=AsQueue[s-1];AsQueue[s-1]->LOR='1';AsQueue[s]->Parent=n;AsQueue[s-1]->Parent=n;AsQueue._Pop_back_n(2);AsQueue.push_back(n);sort(AsQueue.begin(),AsQueue.end(),Compare);}Root=AsQueue[0];Root->LOR=-1;}//设置编码void HuffmanCode::ErgodicTree(){//从叶子节点向树顶端搜索直至根节点获取编码int temp=Show.size();for(int i=0;i<temp;i++){Node*n=Show[i];string c;while(-1!=n->LOR){c.push_back(n->LOR);n=n->Parent;}int temp2=c.size();for(int j=temp2-1;j>-1;j--){Show[i]->Code.push_back(c[j]);}}}//释放节点void HuffmanCode::Delete(Node*n){if(n->Left){四、实验代码动态规划算法解决矩阵连乘问题源程序代码#include<iostream>using namespace std;int MatrixChain(int n, int **m, int **s, int *p); void Traceback(int i, int j, int **s);{s[i] = new i nt[n + 1];m[i] = new i nt[n + 1];}cout << endl;cout <<"输入"<< n + 1 <<"个数据:\n";for (int i = 0; i <= n; i++){cout <<"第"<< i + 1 <<"个数据"<< endl;cin >> p[i];}cout <<"矩阵的最少计算次数为:"<< MatrixChain(n, m, s, p) << endl;cout <<"矩阵最优计算次序为:"<< endl;Traceback(1, n, s);system("pause");return 0;}int MatrixChain(int n, int **m, int **s, int *p){for (int i = 1; i <= n; i++){m[i][i] = 0;}for (int r = 2; r <= n; r++){for (int i = 1; i <= n - r + 1; i++){int j = i + r - 1;m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];s[i][j] = i;for (int k = i + 1; k<j; k++){int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];if (t<m[i][j]){m[i][j] = t;s[i][j] = k;}}}}return m[1][n];}void Traceback(int i, int j, int **s){if (i == j) return;Traceback(i, s[i][j], s);Traceback(s[i][j] + 1, j, s);cout <<"Multiply A"<<i<<","<<s[i][j];cout <<" and A"<< (s[i][j] + 1) <<","<<j<< endl; }回溯法解决n后问题源程序代码#include<iostream>#include<math.h>using namespace std;class Queen{friend int nQueen(int);private:bool Place(int k);void Backtrack(int t);int n, //皇后个数*x; //当前解long sum; //当前已找到的可行方案数};bool Queen::Place(int k){for (int j = 1; j<k; j++){if ((abs(k - j) == abs(x[j] - x[k])) || (x[j] == x[k])){return false;}}return true;}void Queen::Backtrack(int t){if (t>n){sum++;for (int i = 1; i <= n; i++){cout <<"x["<< i <<"]="<< x[i] <<" ";}cout << endl;}else{for (int i = 1; i <= n; i++){x[t] = i;if (Place(t)){Backtrack(t + 1);}}}}int nQueen(int n){Queen X;//初始化XX.n = n;X.sum = 0;int *p = new i nt[n + 1];for (int i = 0; i <= n; i++)p[i] = 0;X.x = p;X.Backtrack(1);delete[]p;return X.sum;}void main(){cout <<"Question n queen,please input n:";int p, q;cin >> p;q = nQueen(p);cout <<"The number of the solution is:"<< q << endl;system("pause");}四、实验代码#include"iostream"namespace std;用来记录矩阵的行列,main函数中有说明//找m[i][j]的最小值,先初始化一下,令k=im[i][j]=m[i][i]+m[i+1][j]+p[i-1]*p[i]*p[j];s[i][j]=i;//k从i+1到j-1循环找m[i][j]的最小值for(int k = i+1;k<j;k++){int temp=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];if(temp<m[i][j]){m[i][j]=temp;//s[][]用来记录在子序列i-j段中,在k位置处//断开能得到最优解s[i][j]=k;}}}}void traceback(int i,int j){if(i==j)return ;traceback(i,s[i][j]);traceback(s[i][j]+1,j);cout<<"Multiply A"<<i<<","<<s[i][j]<<"and A"<<s[i][j]+1<<","<<j<<endl;}int main(){cout<<"输入矩阵的个数:";cin>>n;cout<<"输入矩阵的参数"<<endl;for(int i=0;i<=n;i++)cin>>p[i];matrixChain();traceback(1,n);cout<<m[1][n]<<endl;for(int i=1;i<=n;i++){for(int j=1;j<=n;j++){cout<<m[i][j]<<" ";}cout<<endl;}system("pause");return 0;}五、实验心得通过本次实验,我较为透彻的理解了动态规划算法的几个基本步骤。