最大子段和问题

最大子段和问题
最大子段和问题

昆明理工大学信息工程与自动化学院学生实验报告

( 2012 —2013 学年 第 1 学期 )

课程名称:算法分析与设计 开课实验室: 445 2012 年12月20日

一、上机目的及内容

1.上机内容

给定有n 个整数(可能有负整数)组成的序列(a 1,a 2,…,a n ),求改序列形如

∑=j

k k

a

1

的子段和的

最大值,当所有整数均为负整数时,其最大子段和为0。 2.上机目的

(1)复习数据结构课程的相关知识,实现课程间的平滑过渡; (2)掌握并应用算法的数学分析和后验分析方法;

(3)理解这样一个观点:不同的算法能够解决相同的问题,这些算法的解题思路不同,复杂程度不同,解题效率也不同。

二、实验原理及基本技术路线图(方框原理图或程序流程图)

(1)分别用穷举法、分治法和动态规划法设计最大子段和问题的算法; (2)对所设计的算法采用大O 符号进行时间复杂性分析;

(3)上机实现算法,并用计数法和计时法分别测算算法的运行时间; (4)通过分析对比,得出自己的结论。

三、所用仪器、材料(设备名称、型号、规格等或使用软件)

1台PC 及VISUAL C++6.0软件

四、实验方法、步骤(或:程序代码或操作过程)

1.分治法求解程序代码:

//分治法求解最大子段和问题

#include

#define M 6

int main()

{

int maxsum(int a[],int left,int right);

int a[M],left,right;

printf("请输入%d个数:",M);

//scanf("%d",&M);

printf("\n");

for(int i=0;i<=M-1;i++)

{

scanf("%d",&a[i]);

}

left=0;

right=M-1;

printf("最大子段和为:%d\n\n",maxsum(a,left,right));

return 0;

}

int maxsum(int a[],int left,int right)

{

int sum,center,lefts,rights,s1,s2,leftsum,rightsum;

sum=0;

if(left==right)

{

if(a[left]>0) sum=a[left];

else sum=0;

}

else

{

center=(left+right)/2;

leftsum=maxsum(a,left,center);

rightsum=maxsum(a,center+1,right);

s1=0;lefts=0;

for(int i=center;i>=left;i--)

{

lefts=lefts+a[i];

if(lefts>s1) s1=lefts;

}

s2=0;rights=0;

for(int j=center+1;j<=right;j++)

{

rights=rights+a[j];

if(rights>s2) s2=rights;

}

sum=s1+s2;

if(sum

if(sum

//printf("%d",sum);

}

return sum;

}

2.蛮力法求解程序代码:

#include

#define M 6 //序列长度

int main(void)

{

int i,a[M];

int maxSums(int a[]);

printf("请输入%d个整数序列\n",M);

for(i=0;i

{

scanf("%d",&a[i]);

}

printf("最大子段和为:%d\n",maxSums(a));

return 0;

}

int maxSums(int a[])

{ int center,leftsum,rightsum,s1,s2,lefts,rights;

int i,j,k,maxnum=0,temp=0;

for(k=0;k

for(i=k;i

{

for(j=k;j<=i;j++)

{

temp=temp+a[j];

}

if(temp>maxnum)

{

maxnum=temp;

}

temp=0;

}

return maxnum;

}

3.动态规划法求解程序代码:

#include

#define M 6 // 数组的长度

int dt(int array[], int n);

int main()

{

int i, n = M;

int array[n];

printf("请输入%d个数:",M);

printf("\n");

for(i = 0; i < n; i++)

{

scanf("%d",&array[i]);

}

printf("\n最大子段和为:%d\n", dt(array, n));

return 0;

}

//动态规划法

int dt(int array[], int n)

{

int sumArray[n], sum, i;

sumArray[0] = array[0];

sum = sumArray[0] > 0 ? sumArray[0] : 0;

for(i = 1; i < n; i++)

{

sumArray[i] = (sumArray[i - 1] > 0) ? (sumArray[i-1]+array[i]) : array[i];

if(sum < sumArray[i])

sum = sumArray[i];

}

return sum;

}

五、实验过程原始记录( 测试数据、图表、计算等)

1.分治法求解:

根据提示输入6个数字 -20,11,-4,13,-5,-2 求的该序列的最大子段和为11-4+13=20 输入一个全零的序列,由最大子段和定义知道其最大子段和等于0. 分治法求解最大子段和的时间复杂度T(n)=O(nlog(n))

2.蛮力法求解:

根据提示输入6个数字 -20,11,-4,13,-5,-2 求的该序列的最大子段和为11-4+13=20 输入一个全零的序列,由最大子段和定义知道其最大子段和等于0. 蛮力法求解最大子段和的时间复杂度T(n)=O(n2)。

3.动态规划法求解:

根据提示输入6个数字 -20,11,-4,13,-5,-2 求的该序列的最大子段和为11-4+13=20 输入一个全零的序列,由最大子段和定义知道其最大子段和等于0.

蛮力法求解最大子段和的时间复杂度T(n)=O(n)。

六、实验结果、分析和结论(误差分析与数据处理、成果总结等。其中,绘制曲线图时必须用计算纸或程序运行结果、改进、收获)

同样的问题可以用不同的方法解决,一个好的算法是反复努力和重新修正的结果。虽然蛮力法,分治法,动态规划法都可以解决最大子段和这个问题,但是这些方法的时间复杂度各不相同,时间复杂度越低,代表这个方法更优越。

分治法的思想是将大的问题划分为相同规模的小问题,分别对这些问题求解,最后将子问题综合得到原问题的解。

蛮力法就是穷举法,直接对问题求解,方法直接,但是算法效率最低。

动态规划法将原问题划分为若干个相互重叠的子问题,分析问题是否满足最有性原理,找出动态规划函数的递推式,利用递推式自底向上计算,最终得到结果。

通过这次实验,我对动态规划法有了深刻的理解,同时也对前面所学的蛮力法和分治法进行了复习,体会到算法设计技术的思想方法。

注:教师必须按照上述各项内容严格要求,认真批改和评定学生成绩。

算法分析与设计 实验三 最大子段和问题

昆明理工大学信息工程与自动化学院学生实验报告 ( 201 — 201 学年 第 1 学期 ) 课程名称:算法分析与设计 开课实验室: 年 月 日 一、上机目的及内容 1.上机内容 给定有n 个整数(可能有负整数)组成的序列(a 1,a 2,…,a n ),求改序列形如 ∑=j k k a 1 的子段和的 最大值,当所有整数均为负整数时,其最大子段和为0。 2.上机目的 (1)复习数据结构课程的相关知识,实现课程间的平滑过渡; (2)掌握并应用算法的数学分析和后验分析方法; (3)理解这样一个观点:不同的算法能够解决相同的问题,这些算法的解题思路不同,复杂程度不同,解题效率也不同。 二、实验原理及基本技术路线图(方框原理图或程序流程图) (1)分别用穷举法、分治法和动态规划法设计最大子段和问题的算法; (2)对所设计的算法采用大O 符号进行时间复杂性分析; (3)上机实现算法,并用计数法和计时法分别测算算法的运行时间; (4)通过分析对比,得出自己的结论。 穷举法是用一个二维数组将从i 到j 的和都记录下来,再比较各元素的大小,时间复杂性为O (n 2),分治法的设计思想是不断将问题为子问题,然后求解子问题,最后对解进行合并,时间复杂性为O(nlog n ),动态规划法的设计思想是将问题划分为若干个子问题,时间复杂度为O(n)。

分治法流程图:

穷举法流程图: 动态规划法流程图: 三、所用仪器、材料(设备名称、型号、规格等或使用软件) 1台PC 及VISUAL C++6.0软件

四、实验方法、步骤(或:程序代码或操作过程) 程序代码: //穷举法 #include void main() { int i,j,n; int num[100],a[100],max; printf("\t\t\t 最大子段和问题(穷举法)\n\n"); printf("请输入所要求最大字段和整数的个数:\n"); scanf("%d",&n); printf("请分别输入这%d个整数的值:\n",n); for(i=0;i int MaxSum(int a[],int left,int right) { int sum=0; if (left==right) {

算法练习题-分章节-带答案

算法练习题-分章节-带答案

算法练习题---算法概述 一、选择题 1、下面关于算法的描述,正确的是() A、一个算法只能有一个输入 B、算法只能用框图来表示 C、一个算法的执行步骤可以是无限的 D、一个完整的算法,不管用什么方法来表示,都至少有一个输出结果 2、一位爱好程序设计的同学,想通过程序设计解决“韩信点兵”的问题,他制定的如下工作过程中,更恰当的是() A、设计算法,编写程序,提出问题,运行程序,得到答案 B、分析问题,编写程序,设计算法,运行程序,得到答案 C、分析问题,设计算法,编写程序,运行程序,得到答案 D、设计算法,提出问题,编写程序,运行程序,得到答案 3、下面说法正确的是() A、算法+数据结构=程序 B、算法就是程序 C、数据结构就是程序 D、算法包括数据结构 4、衡量一个算法好坏的标准是()。 A、运行速度快 B、占用空间少 C、时间复杂度低 D、代码短 5、解决一个问题通常有多种方法。若说一个算法“有效”是指( )。 A、这个算法能在一定的时间和空间资源限制内将问题解决 B、这个算法能在人的反应时间内将问题解决 C、这个算法比其他已知算法都更快地将问题解决 D、A和C 6、算法分析中,记号O表示(),记号Ω表示()。 A.渐进下界 B.渐进上界 C.非紧上界 D.非紧下界 7、以下关于渐进记号的性质是正确的有:() A.f(n)(g(n)),g(n)(h(n))f(n)(h(n)) =Θ=Θ?=Θ B.f(n)O(g(n)),g(n)O(h(n))h(n)O(f(n)) ==?= C. O(f(n))+O(g(n)) = O(min{f(n),g(n)}) D.f(n)O(g(n))g(n)O(f(n)) =?=

最大子段和动态规划法

实验名称: 最大子段和问题 实验目的: 了解最大子段和问题 实验环境: 操作系统:Windows XP Professional SP3 机器配置:Intel Pentium4 CPU 3.0GHz , 512MB 内存 开发工具:eclipse 实验内容: 1. 求数列的最大子段和(要求时间复杂为nlogn) (算法设计与分析 吕国英 清华大学出 版社 135页 4..3.3 二分法变异) (分治法) (也可用动态规划算法 参看递归王晓东计算机算法设计与分析第三版p61页) 算法的设计思想: 在对分治法德算法分析中注意到,若记???? ? ? <=<==∑=j i k k a n j i i b ][max ][,1<=j<=n,则所求的 最大子段和为: ][1max ][1max 1max ][1max j b n j k a j i n j k a n j i j i k j i k <=<== <=<=<=<==????? ?<=<=<=∑ ∑== 分为两种情况: (1)、当b[j-1]>0时,b[j]=b[j-1]+a[j]。 (2)、当b[j-1]<0时,b[j]=a[j]。 由此可得计算b[j]的动态规划递归式为: b[j]=max }{][],[]1[j a j a j b +-,1<=j<=n 由分析可知:次算法一共比较了n 次,故: T(n)=O(n)

据此可以写出如下程序: 实验步骤: 程序代码如下: package s; public class Po{ public static void main(String[] args) { int[] a=new int[10]; int[] b=new int[10]; int[] x=new int[10]; int start=0; int end = 0; System.out.print("数组为:");//随机赋值 for(int i =0;i<10;i++){ a[i]=(int)(Math.random()*100-50); System.out.print(a[i]+" "); } System.out.print("\n"); tem(a,x,b); int max=maxSum(a,b,end); System.out.print("最大子段和为:"); System.out.println(max); System.out.print("结束位置为:"); System.out.println(findend(a,b,end)); int begin=findStart(a,b,start,end); System.out.print("开始位置为:"); System.out.println(begin); systemout(x,start,end,a,b); } public static void tem(int a[],int x[],int b[]) {int n=a.length-1; int sum=0; b[0]=x[0];

分治法求最大子段和问题

分治法求最大子段和问题 共有四种方法: 算法一; 算法二; 算法三、Divide and Conquer 算法四源代码、On-line Algorithm 算法一源代码: /*Given (possibly negative) integers A1, A2, …, AN, find the maximum value. 找最大子段和*/ #include #include #include intMaxSubsequenceSum(int A[],int N); main() { inti,N,*A,MaxSum,judge; LARGE_INTEGER begin,end,frequency; //代表64位有符号整数,记录程序运行时间QueryPerformanceFrequency(&frequency);//可以获得当前的处理器的频率 printf("输入整数的个数:"); scanf("%d",&N); A=(int *)malloc(N*sizeof(int)); //用数组给数据动态分配空间 printf("自行输入数据请按1,随机产生数据请按2\n"); scanf("%d",&judge); if(judge==1){ //自行输入数据 printf("输入%d个整数:",N); for(i=0;i

最大子序列和的总结

最大子序列和 第一种情况:可以一个不取 【问题描述】:最大子序列和也叫数列的连续最大和,顾名思义,就是在一个长度为n的数列{An}中,求i,j(1<=i<=j<=n),使得数列{An}中,第i个元素到第j个元素之间,所有元素的和最大。例如:-2, 11, -4, 13, -5, -2时答案为20(11 -4 13) 解法一穷举法:以前我想出了一种算法,具体做法是:取出所给序列的所有子序列求和,共分n组,第一组长度为1,有n个;第二组长度为2, 有n-1个;……,最后一组,长度为n,只有一个。比较这n(n+1)/2个序列的和,再将每组的最大值比较,从而得到最大值以及其上下标。 a1 a2 a n-1 a n a1+a2 a2+a3 a n-1+a n a1+a2+a3 a2+a3+a4 ...... ...... ...... a1+a2......+a n-1 a2+a3......+a n a1+a2......+a n-1 +a n 此算法比较直接,也容易写出代码,但其时间开销为O(n2),空间开销为O(n),效率不高。 解法二:动态规划求解, 1 2 F[i]:表示以元素i结尾的连续最大子序列的和 那么对于第i个元素来说,要形成连续的最大子序列,只和相邻的前一个元素有关。因为可以不取,所以如果元素a[i]连接到以元素i-1结尾的最大连续子序列f[i-1]后是负数(f[i-1]+a[i]<0);则宁可不取,这样最大连续子序列和为0。 动态方程: f[i]:=max{0,f[I-1]+a[i]} (边界条件:f[0]=0;) 3、代码1: for I:=1 to n do if (f[I-1]+a[i])>0 then f[i]:=f[I-1]+a[i] else f[i]:=0; max:=-maxlongint; for i:=1 to n do if f[i]>max then max:=f[i];

常见动态规划算法问题策略分析

常见动态规划算法问题 策略分析

目录 一、动态规划策略 (1) 1.动态规划介绍 (1) 2.求解动态规划问题步骤 (1) 二、几种动态规划算法的策略分析 (1) 1.装配线调度问题 (1) 2.矩阵链乘问题 (2) 3.最长公共子序列(LCS) (3) 4.最大字段和 (4) 5.0-1背包问题 (4) 三、两种解决策略 (5) 1.自底向上策略 (5) 2.自顶向上(备忘录)策略 (5) 3.优缺点分析 (5) 四、总结 (6)

一、动态规划策略 1.动态规划介绍 动态规划过程是:每次决策依赖于当前状态,又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的,所以,这种多 阶段最优化决策解决问题的过程就称为动态规划。 基本思想与分治法类似,也是将待求解的问题分解为若干个子问题(阶段),按顺序求解子阶段,前一子问题的解,为后一子问题的 求解提供了有用的信息。在求解任一子问题时,列出各种可能的局部 解,通过决策保留那些有可能达到最优的局部解,丢弃其他局部解。 依次解决各子问题,最后一个子问题就是初始问题的解。 由于动态规划解决的问题多数有重叠子问题这个特点,为减少重复计算,对每一个子问题只解一次,将其不同阶段的不同状态保存在 一个二维数组中。 与分治法最大的差别是:适合于用动态规划法求解的问题,经分解后得到的子问题往往不是互相独立的(即下一个子阶段的求解是建 立在上一个子阶段的解的基础上,进行进一步的求解)。 2.求解动态规划问题步骤 (1)确定最优解结构 (2)递归定义最优解的值 (3)自底向上计算最优解的值 (4)重构最优解 二、几种动态规划算法的策略分析 1.装配线调度问题 分析:首先确定最优解结构,分析问题可知大致分为两种情况:

算法分析习题详细答案五

1.最大子段和问题:给定整数序列 n a a a ,,,21 ,求该序列形如 j i k k a 的子段和 的最大值: j i k k n j i a 1max ,0max 1) 已知一个简单算法如下: int Maxsum(int n,int a,int& best i,int& bestj){ int sum = 0; for (int i=1;i<=n;i++){ int suma = 0; for (int j=i;j<=n;j++){ suma + = a[j]; if (suma > sum){ sum = suma; besti = i; bestj = j; } } } return sum; }试分析该算法的时间复杂性。 2) 试用分治算法解最大子段和问题,并分析算法的时间复杂性。 3) 试说明最大子段和问题具有最优子结构性质,并设计一个动态规划算法解最大子段和问题。分析算法的时间复杂度。 (提示:令1()max ,1,2,,j k i j n k i b j a j n L ) 解:1)分析按照第一章,列出步数统计表,计算可得)(2 n O 2)分治算法:将所给的序列a[1:n]分为两段a [1:n/2]、a[n/2+1:n],分别求出这两段的最大子段和,则a[1:n]的最大子段和有三种可能: ①a[1:n]的最大子段和与a[1:n/2]的最大子段和相同; ②a[1:n]的最大子段和与a[n/2+1:n]的最大子段和相同; ③a[1:n]的最大子段和为两部分的字段和组成,即 j n j i l n i j a a a a a 122;

intMaxSubSum ( int *a, int left , int right){ int sum =0; if( left==right) sum = a[left] > 0? a[ left]:0 ; else {int center = ( left + right) /2; int leftsum =MaxSubSum ( a, left , center) ; int rightsum =MaxSubSum ( a, center +1, right) ; int s_1 =0; int left_sum =0; for ( int i = center ; i >= left; i--){ left_sum + = a [ i ]; if( left_sum > s1) s1 = left_sum; } int s2 =0; int right_sum =0; for ( int i = center +1; i <= right ; i++){ right_sum + = a[ i]; if( right_sum > s2) s2 = right_sum; } sum = s1 + s2; if ( sum < leftsum) sum = leftsum; if ( sum < rightsum) sum = rightsum; } return sum; } int MaxSum2 (int n){ int a; returnMaxSubSum ( a, 1, n) ; } 该算法所需的计算时间T(n)满足典型的分治算法递归分式T(n)=2T(n/2)+O(n),分治算法的时间复杂度为O(nlogn)

运筹学之动态规划(东南大学)汇总

引言——由一个问题引出的算法 考虑以下问题 [例1] 最短路径问题 现有一张地图,各结点代表城市,两结点间连线代表道路,线上数字表示城市间的距离。如图1所示,试找出从结点A到结点E的最短距离。 图 1 我们可以用深度优先搜索法来解决此问题,该问题的递归式为 其中是与v相邻的节点的集合,w(v,u表示从v到u的边的长度。 具体算法如下: 开始时标记所有的顶点未访问过,MinDistance(A就是从A到E的最短距离。 这个程序的效率如何呢?我们可以看到,每次除了已经访问过的城市外,其他城市都要访问,所以时间复杂度为O(n!,这是一个“指数级”的算法,那么,还有没有更好的算法呢? 首先,我们来观察一下这个算法。在求从B1到E的最短距离的时候,先求出从C2到E的最短距离;而在求从B2到E的最短距离的时候,又求了一遍从C2到E的最短距离。也就是说,从C2到E的最短距离我们求了两遍。同样可以发现,在求从C1、C2到E的最短距离的过程中,从D1到E的最短距离也被求了两遍。而在整个程序中,从D1到E的最短距离被求了四遍。如果在求解的过程中,同时将求得的最短距离"记录在案",随时调用,就可以避免这种情况。于是,可以改进该算法,将每次求出的从v到E的最短距离记录下来,在算法中递归地求MinDistance(v时先检查以前是否已经求过了MinDistance(v,如果求过了则不用重新求一遍,只要查找以前的记录就可以了。这样,由于所有的点有n个,因此不同的状态数目有n 个,该算法的数量级为O(n。 更进一步,可以将这种递归改为递推,这样可以减少递归调用的开销。 请看图1,可以发现,A只和Bi相邻,Bi只和Ci相邻,...,依此类推。这样,我们可以将原问题的解决过程划分为4个阶段,设

最大字段和问题

最大字段和问题 1.实验题目 给定由N 个整数(可能有负整数)组成的序列(1a ,2a ,…,n a ),求该序列形如∑=j i k k a 的子段和的最大值,当所有整数均为负整数是,其最大子段和为0。 2.实验目的 (1)深刻掌握动态规划法的设计思想并能熟练运用; (2)理解这样一个观点:同样的问题可以用不同的方法解决,一个好的算法是反复努力和重新修正的结果。 3.实验分析 蛮力法:利用3个for 的嵌套(实现从第1个数开始计算子段长度为1,2,3…n 的子 段和,同理计算出第2个数开始的长度为1,2,3…n-1的子段和,依次类推到第n 个数开始计算的长为1的子段和)和一个if (用来比较大小),将其所有子段的和计算出来并将最大子段和赋值给summax1。 用了3个for 嵌套所以时间复杂性为○(n 3)。 分治法: (1)划分:按照平衡子问题的原则,将序列(1a ,2a ,…,n a )划分成长度相同的 两个字序列(1a ,…,??2/n a )和(??12/+n a ,…,n a ) 。 (2)求解子问题:对于划分阶段的情况分别的两段可用递归求解,如果最大子段和在 两端之间需要分别计算 s1=?? ??)2/1(max 2/n i a n i k k ≤≤∑=,s2=????)2/(max 12/n j n a j n k k ≤≤∑+=, 则s1+s2为最大子段和。若然只在左边或右边,那就好办了,前者视s1为summax2,后者视s2 o summax2。 (3)合并:比较在划分阶段的3种情况下的最大子段和,取三者之中的较大者为原问 题的解。 (4)时间复杂性分析: f(n) = 2*f(n/2) + ○(n/2), 最后为○(nlogn)。 动态规划法: 动态规划法求解最大字段和问题的关键是要确定动态规划函数。记 )1(max )(1n j a j b i i k k j i ≤≤? ?????=∑=≤≤ 则

最大字段和

最大字段和 【实验目的】 1掌握动态规划法的设计思想并能熟练运用; 2分别用分治法和动态规划法设计最大子段和问题的算法; 【实验设备与环境】 1 PC机一台 2 Turbo C 或VC++ 【实验内容:】 给定由n个整数(可能为负整数)组成的序列a1, a2, …, an,求该序列形如的子段和的最大值,当所有整数均为负整数时定义其最大子段和为0。 【实验方法步骤】 1用分治法求最大子段和 程序代码: #include int MaxSum(int a[],int left,int right) { int i,sum=0; if(left==right) sum=a[left]>0?a[left]:0; else { int center=(left+right)/2; int leftsum=MaxSum(a,left,center); int rightsum=MaxSum(a,center+1,right); int s1=0,s2=0,lefts=0,rights=0; for(i=center;i>=left;i--) { lefts+=a[i]; if(lefts>s1) s1=lefts; }

for(i=center+1;i<=right;i++) { rights+=a[i]; if(rights>s2) s2=rights; } sum=s1+s2; if(sum

算法(复习题)1

平均情况:设待查找的元素在数组中的概率为P,不在数组中的概率为1-P,若出现在数组中每个位置的概率是均等的为p/n T(n)=P1D1+P2D2+...+PiDi+(1-P)Dn+1 =p/2+n(1-p/2) 1.叙述分治算法和动态规划算法的基本思想,并比较两种算法的异同。答:分治法将待求解的问题划分成K个较小规模的子问题,对这K个子问题分别求解,再将子问题的解合并为一个更大规模的问题的解,自底向上逐步求出原问题的解. 动态规划将待求解的问题分解成若干的子问题,自底向上地通过求解子问题的解得到原问题的解。动态规划将每个子问题只求解一次并将其解保存在一个表格中,当需要再次求解此子问题时,只是简单的通过查表过的该子问题的解,避免了大量的重复计算. 异同:分治法求解的问题分解后的子问题都是独立的,而使用动态规划求解的问题分解后得到的子问题往往不是相互独立的。 分治法是自顶向下用递归的方法解决问题,而动态规划则是自底向上非递归解决问题。 1.简述分治算法求解过程的三个阶段。 答:(1)划分:既然是分治,当然需要把规模为n的原问题划分为k个规模较小的子问题,并尽量使这k个子问题的规模大致相同。 (2)求解子问题:各子问题的解法与原问题的解法通常是相同的,可以用递归的方法求解各个子问题,有时递归处理也可以用循环来实现。 (3)合并:把各个子问题的解合并起来,合并的代价因情况不同有很大差异,分治算法的有效性很大程度上依赖于合并的实现。 2.叙述分治法的基本思想,并分析分治法与减治法二者的区别。 答:分治法将待求解的问题划分成K个较小规模的子问题,对这K个子问题分别求解,再将子问题的解合并为一个更大规模的问题的解,自底向上逐步求出原问题的解. 区别:分治法是把一个大问题划分成若干个子问题,分别求解各个子问题,然后把子问题的解进行合并并得到原问题的解。减治法同样是把一个大问题划分成若干个子问题,但是这些子问题不需要分别求解,只需求解其中的一个子问题,因而也无需对子问题的解进行合并。 3.设计分治算法求一个数组中最大元素的位置,建立该算法时间复杂性的 递推式并给出其复杂性的大O表示。 答:设数组a1,a2...an int maxpos(a[],i,j); {if(i==j) return i; mid=(i+j)/2; lmaxpos=maxpos(a,i,mid); rmaxpos=maxpos(a,mid+1,j); if(a[lmaxpos]>=a[rmoxpos]) return lmaxpos; else return rmaxpos;} T(1)=O(n) n=1; T(n)=2T(n/2)+O(1) n>1;

最大子段和三种求解方法

1、最大子段和问题的简单算法: 代码: #include using namespace std; int MaxSum(int a[],int n,int &besti,int &bestj){ int sum=0; int i,j,k; for(i=1;i<=n;i++) for(j=i;j<=n;j++) { int thissum=0; for(k=i;k<=j;k++)thissum+=a[k]; if(thissum>sum){ sum=thissum; besti=i; bestj=j; } } return sum; } int main(){ int n,a[100],m,i,j,maxsum; cout<<"请输入整数序列的元素个数n:"<>n; cout<<"请输入序列中各元素的值a[i](一共"<>a[m]; for(m=0;m>a[m]; int b[100];

for(m=0;m using namespace std; int MaxSum(int a[],int n,int &besti,int &bestj){ int sum=0; int i,j,k; for(i=1;i<=n;i++){ int thissum=0; for(j=i;j<=n;j++) { thissum+=a[j]; if(thissum>sum){ sum=thissum; besti=i; bestj=j; } } } return sum; }

算法分析考试题

1. )(n T 给定数组a[0:n-1],试设计一个算法,在最坏情况下用n+[logn]-2次比较找出 a[0:n-1] 中的元素的最大值和次大值. (算法分析与设计习题 2.16 ) (分治法) a 、 算法思想 用分治法求最大值和次大值首先将问题划分,即将划分成长度相等的两个序列,递归求出左边的最大值次大值,再求出右边的的最大值次大值,比较左右两边,最后得出问题的解。 b 、复杂度分析: 把问题划分为左右两种的情况,需要分别递归求解,时间复杂度可如下计算: 有递推公式为: T(n)=1 n=1 T(n)= 2T(n/2)+1 n>1 所以,分治算法的时间复杂度是n+[logn]-2,当n 为奇数时,logn 取上线,当n 为偶数时,logn 取下线。//不知道为什么会-2! C 、代码实现: #include int a[100]; void maxcmax(int i,int j,int &max,int &cmax) { int lmax,lcmax,rmax,rcmax; int mid; if (i==j) { max=a[i]; cmax=a[i]; } else if (i==j-1) if (a[i]rmax)

if(lcmax>rmax) { max=lmax; cmax=lcmax; } else { max=lmax; cmax=rmax; } else if(rcmax>lmax) { if(rmax==rcmax) { max=rmax; cmax=lmax; } else { max=rmax; cmax=rcmax; } } else { max=rmax; cmax=lmax; } } } int main() { int n; int max,cmax; printf("输入数组长度"); scanf("%d",&n); printf("输入数组:\n"); for(int i=0;i

最大子段和问题实验报告

实验四最大子段和问题 1.实验目的 (1)掌握动态规划的设计思想并能熟练运用; (2)理解这样一个观点:同样的问题可以用不同的方法解决,一个好的算法是反复努力和重新修正的结果; 2.实验要求 (1)分别用蛮力法、分治法和动态规划法设计最大子段和问题的算法; (2)比较不同算法的时间性能; (3)给出测试数据,写出程序文档; 3.实验设备和软件环境 操作系统:Windows 7(64x) 开发工具:Visual Studio 2013 4.实验步骤 以下实验数据都是以数组a[]={-2, 11, -4, 13, -5, -2}为例子; 蛮力法 蛮力法是首先通过两个for循环去求出所有子段的值,然后通过if语句查找出maxsum,返回子序列的最大子段和; 分治法 (1)划分:按照平衡子问题的原则,将序列(a1,a2,…,an)划分成长度相同的两个子序列(a1,a2,...,an/2)和(an/2+1,…,an); (2)求解子问题:对与划分阶段的情况①和②可递归求解,情况③需要分别计算

s1=max{}(1<=i<=n/2),s2=max{}(n/2+1<=j<=n),则s1+s2为情况③的最大子段和。 (3)合并:比较在划分阶段三种情况下的最大子段和,取三者中比较大者为原问题的解。动态规划法划分子问题 (1)划分子问题; (2)确定动态规划函数; (3)填写表格; 分为两种情况: (1)、当b[j-1]>0时,b[j]=b[j-1]+a[j]。 (2)、当b[j-1]<0时,b[j]=a[j] 然后做递归操作求出最大子段和; 5.实验结果 蛮力法 #include #include<> using namespace std; /*------------------------------------------------------------------------------*/ int manlifa(int a[],int x) { int i, j,sum=0,maxsum=0; for (i = 0; i < x; i++) { for (j = i+1; j < x; j++) { sum = a[i]; a[i] += a[j]; if (a[i]>sum) { sum = a[i]; } if (sum>maxsum) { maxsum = sum;

算法分析作业

算法分析练习题(一) 一、选择题 1、二分搜索算法是利用( A )实现的算法。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 2、下列不是动态规划算法基本步骤的是( A )。 A、找出最优解的性质 B、构造最优解 C、算出最优解 D、定义最优解 3.下列算法中通常以自底向上的方式求解最优解的是( B )。 A、备忘录法 B、动态规划法 C、贪心法 D、回溯法 4、衡量一个算法好坏的标准是(C )。 A 运行速度快 B 占用空间少 C 时间复杂度低 D 代码短 5、以下不可以使用分治法求解的是(D )。 A 棋盘覆盖问题 B 选择问题 C 归并排序 D 0/1背包问题 6. 实现循环赛日程表利用的算法是( A )。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 7.备忘录方法是那种算法的变形。( B ) A、分治法 B、动态规划法 C、贪心法 D、回溯法8.最长公共子序列算法利用的算法是( B )。 A、分支界限法 B、动态规划法 C、贪心法 D、回溯法9.实现棋盘覆盖算法利用的算法是( A )。 A、分治法 B、动态规划法 C、贪心法 D、回溯法 10. 矩阵连乘问题的算法可由(B)设计实现。 A、分支界限算法 B、动态规划算法 C、贪心算法 D、回溯算法 11、Strassen矩阵乘法是利用( A )实现的算法。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 12、使用分治法求解不需要满足的条件是(A )。 A 子问题必须是一样的 B 子问题不能够重复

C 子问题的解可以合并 D 原问题和子问题使用相同的方法解 13、下列算法中不能解决0/1背包问题的是(A ) A 贪心法 B 动态规划 C 回溯法 D 分支限界法 14.实现合并排序利用的算法是( A )。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法15.下列是动态规划算法基本要素的是( D )。 A、定义最优解 B、构造最优解 C、算出最优解 D、子问题重叠性质 16.下列算法中通常以自底向下的方式求解最优解的是( B )。 A、分治法 B、动态规划法 C、贪心法 D、回溯法 17、合并排序算法是利用( A )实现的算法。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 18.实现大整数的乘法是利用的算法( C )。 A、贪心法 B、动态规划法 C、分治策略 D、回溯法 19. 实现最大子段和利用的算法是( B )。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 20. 一个问题可用动态规划算法或贪心算法求解的关键特征是问题的( B )。 A、重叠子问题 B、最优子结构性质 C、贪心选择性质 D、定义最优解 21. 实现最长公共子序列利用的算法是( B )。 A、分治策略 B、动态规划法 C、贪心法 D、回溯法 二、填空题 1.算法的复杂性有时间复杂性和空间复杂性之分。 2、程序是算法用某种程序设计语言的具体实现。 3、算法的“确定性”指的是组成算法的每条指令是清晰的,无歧义的。 4.矩阵连乘问题的算法可由动态规划设计实现。 5、算法是指解决问题的一种方法或一个过程。

最大子列和

算法分析与设计实验报告 拓展实验1

} 算法1结果: 算法2结果:

附录:完整代码 #include #include #include using namespace std; 算法3 结果: 算法4结果:

intDivideAndconquer(int[],int,int); constint Max=20; int MaxQSum4(int[],int&,int&,int&); intmain(){ inti,x,m,n,Maxsum,a[Max]; cout<<"请输入序列元素个数:"<>x; srand(time(0)); for( i=0;i50) a[i]=-(rand()%50); cout<max&&sum>0) max=sum; } } if( max==a[0]&&max<0 ) max=0; return max; } */ /*部分穷举 O=n*n int MaxQSum2( int a[Max],int&x){ int max=a[0],sum; for( inti=0;imax&&sum>0)

算法:动态规划解决最大子段和问题

算法:动态规划解决最大子段和问题 /* 动态规划法思想:将较大的问题分解成较小的问题,先求解子问题,然后通过子问题的解得到原问题的解,经过分解的子问题之间并不是 相互独立的。*/ # include # include # include int max_sum(int a[],int n,int *best_i,int *best_j) { // *best_i表示最大子段和的起始下标 // *best_j表示最大子段和的终点下标 // i,j 表示当前子段的起点和终点下标 int i,j; int this_sum[100]; int sum[100]; int max=0; this_sum[0]=0; sum[0]=0; *best_i=0; *best_j=0; i=1; for(j=1;j<=n;j++) { if(this_sum[j-1]>=0) //判断是否为负数 this_sum[j]=this_sum[j-1]+a[j]; else { this_sum[j]=a[j]; i=j; } //如果子段和数组前一个大于下一个元素 if(this_sum[j]<=sum[j-1]) sum[j]=sum[j-1]; //对当前子段和赋值 else { sum[j]=this_sum[j]; *best_i=i; *best_j=j; max=sum[j]; } }

return max; } void main() { int i,j,n,a[100],t; printf("请输入数列的个数(<99):\n"); scanf("%d",&n); printf("请输入数列元素:\n"); for(i=1;i<=n;i++) scanf("%d",&a[i]); i=j=1; t=max_sum(a,n,&i,&j); printf("最大字段和是:%d\n",t); printf("字段起点是:%d\n",i); printf("字段结束点:%d\n",j); }

动态规划算法实验报告

实验标题 1、矩阵连乘 2、最长公共子序列 3、最大子段和 4、凸多边形最优三角剖分 5、流水作业调度 6、0-1背包问题 7、最优二叉搜索树 实验目的掌握动态规划法的基本思想和算法设计的基本步骤。 实验内容与源码1、矩阵连乘 #include #include using namespace std; const int size=4; //ra,ca和rb,cb分别表示矩阵A和B的行数和列数 void matriMultiply(int a[][4],int b[][4],int c[][4],int ra ,int ca,int rb ,int cb ) { if(ca!=rb) cerr<<"矩阵不可乘"; for(int i=0;i

最大子段和算法

最大子段和n3算法 1. int MaxSubseqSum1( int A[], int N ) 2. { int ThisSum, MaxSum = 0; 3. int i, j, k; 4. for( i = 0; i < N; i++ ) { /* i是子列左端位置*/ 5. for( j = i; j < N; j++ ) { /* j是子列右端位置*/ 6. ThisSum = 0; /* ThisSum是从A[i]到A[j]的子列和*/ 7. for( k = i; k <= j; k++ ) 8. ThisSum += A[k]; 9. if( ThisSum > MaxSum ) /* 如果刚得到的这个子列和更大*/ 10. MaxSum = ThisSum; /* 则更新结果*/ 11. } /* j循环结束*/ 12. } /* i循环结束*/ 13. return MaxSum; 14. } 最大子段和n2算法 int MaxSubseqSum2( int A[], int N ) { int ThisSum, MaxSum = 0; int i, j; for( i = 0; i < N; i++ ) { /* i是子列左端位置*/ ThisSum = 0; /* ThisSum是从A[i]到A[j]的子列和*/ for( j = i; j < N; j++ ) { /* j是子列右端位置*/ ThisSum += A[j]; /*对于相同的i,不同的j,只要在j-1次循环的基础上累加1项即可*/ if( ThisSum > MaxSum ) /* 如果刚得到的这个子列和更大*/ MaxSum = ThisSum; /* 则更新结果*/ } /* j循环结束*/ } /* i循环结束*/ return MaxSum; } 最大子段和nlongn算法(分治) int maxSum(int a[],int left, int right) { int sum = 0; if(left == right) //如果序列长度为1,直接求解 { if(a[left] > 0) sum = a[left]; else sum = 0; } else { int center = (left + right) / 2; //划分

相关文档
最新文档