算法设计题打印部分

合集下载

高中信息技术学业水平考试算法与程序设计题、填空题、分析题小抄版含答案

一、解决问题有解析法、穷举法、递归法、冒泡排序法，根据问题选择选择合适的算法。

1. 列举所有可能的情况，逐个判断有哪些是符合问题所需要的条件，从而是得到问题的解答，这是穷举法的思路。

2. 一个玻璃球从高处到自由落体运动。

在达到地面时，速度为98m/s ，请问玻璃求从高处开始下落地面用多长时间？解析法 3、水仙花数是一个三位数，其各位立方和等于该数本身，如153=1*1*1+5*5*5+3*3*3选择的算法是穷举法4、一张单据上有一个5位数的号码67__ __8，其中百位和十位的数字看不清楚了，但知道该数能够被78整除，也能被67整除，设计一个算法求出该号码。

穷举法5.已知：f (1)=1 f (2)=3 当n>2时：F(n)=2f (n -1)+3f (n-2)编程求f (100)的值。

答案：递归法6.求解“百鸡问题”已知公鸡每只3元，母鸡每只5元，每3只小鸡1元，用100元买100只鸡，问每种鸡应各买多少？答案：穷举法___7.国内特快专递每200g 为一个为一个计费单位。

200g 以内20元，200g 以上每续200g （不足200g 按200g 计算16元，现在要编写一个程序输入包裹自动计算出价格。

答案：解析法8.动员成绩进行公布现在要编写一个程序自动完成编排,请问最好采用哪种答案：冒泡排序法二、分析程序写出运行结果或补全程序。

1. Dim a as integer ,b as interge a=1:b=0Do while a<=3 a=a+1 b=b+a*a Loop Print a ,b4 29 2、Dim ch As String , i As Integer ch=”abc ” i=1Do while i<=3Ch=ch&Right(“DEF ”,i) i=i+2 Loop Print ch End sub运行结果是： abcFD 3、 S=0 I=1For I=1 to 4 S=s+i^2 Next i Print “s=”;s运行结果是： s=30 4、Private sub command 1_click() S=0For i=1 to 3 s=s+2*i next iprint “s=”;s End sub运行结果是 s=125、dim s as integer, I as integer S=0 For I = 1 to 10 step 2 S=s+i Next iPrint “s=”;s运行的结果是： s=2561/49的值For i =1 to 49 step 2 S= S+1/i Next i7、计算1+3+5+7+……+99的值 Dim I ,s as integer S=0For I = 1 to 50 S=s+(2*i-1)Next I 8、已知Ｓ=1+2+3+…+N ，找出一个最大的整数Ｎ，使得Ｓ<300. Private Sub S=0 N=0Do while S<300 N=N+1 S=S+N Loop End sub 9、Private Sub Form-Activate ( )Dim I ,S As Integer S=1For I=1 to 4 S=S*IPrint “S=”; S End Sub运行结果: S=2410、Private Sub Form-Activate ( )Dim I Integer ,S As IntegerFor I =2 To 6 S=S+I Next I Print “S=”; S运行结果: S=20 11、Private Sub Form-Load Dim X As Integer, Y AS Integer Text1.Text=” ” X=99 Y=98 M=X If X<Y then M=Y Text1.caption=MEnd Sub运行结果： 9912、Private Sub Form-Activate ( )Dim a b c As Integer a=15 b=60 c=38If a<b then m=a else m=b If m>c then m=c Print “M=” m End Sub运行结果 : M=15 13、计算1+3+5+……+99的值 Private Sub Form-Activate ( )Dim I ,S As Integer S=0For I=1 To 99 step 2S= S+I Print “S=” S End Sub 14、计算1+1/2+…………+1/50的值 Private Sub Form-Activate ( )Dim I ,S As Integer S=0For I=1 to 50 S= S+1/I Print “S=” ; S End Sub15、实现函数：Y=︱X ︱Private Sub Form-Activate ( )Dim X as Integer , Y as single IntegerText1.text=” ” X =Inputer(“X =?”)If X>=0 then ElseY=―X End ifText1.text=Y End Sub16.Private Sub Form_Activate( ) Dim i As Integer , sum As Integersum=0For i =1 To 100 sum=sum+2 Next iPrint “sum=” ; sum End Sub该程序的输出结果是： sum=200 17、写程序结果 Text2=“34”a=(val (Text2)-32)*5/2 print a答案：_5____ 18、完善程序：打印如下图形。

算法与程序设计试题带答案

算法与程序设计试题带答案1. 以下是一道经典的算法题，请编写代码实现求最大公约数（GCD）的算法。

```pythondef gcd(a, b):if b == 0:return areturn gcd(b, a % b)# 测试print(gcd(15, 25)) # 输出 5print(gcd(54, 72)) # 输出 18```解析：这是一个使用递归实现的辗转相除法算法，也叫欧几里得算法。

当两个数 a 和 b 求最大公约数时，如果 b 等于 0，则 a 就是最大公约数；否则，将 b 作为新的 a，将 a 除以 b 的余数作为新的 b 进行递归计算。

2. 请编写代码实现一个链表的反转。

```pythonclass ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef reverse_linked_list(head):prev = Nonecurr = headwhile curr:next_node = curr.nextcurr.next = prevprev = currcurr = next_nodereturn prev# 测试node1 = ListNode(1)node2 = ListNode(2)node3 = ListNode(3)node1.next = node2node2.next = node3reversed_head = reverse_linked_list(node1)while reversed_head:print(reversed_head.val)reversed_head = reversed_head.next```解析：这是一个经典的链表反转算法。

使用 prev、curr、next_node 三个指针来实现，其中 prev 用于保存上一个节点，curr 用于保存当前节点，next_node 用于保存下一个节点。

算法设计练习题

算法设计练习题1、设一棵二叉树以二叉链表为存储结构，结点结构为。

设计一个算法，求在前根序列中处于第k个位置的结点。

2、设某单链表Ｌ的结点结构为编写算法判断该链表的元素是否是递增的。

3、设有一单链表L，结点结构为3个，试画出链表L的结构图，并编写算法判断该单链表L中的元素是否成等差关系，即：设各元素值次为a1,a2,a3,…,a n，判断a i+1-a i=a i-a i-1是否成立，其中i满足2<=i<=n-1.4、设有一棵二叉树以二叉链表作为存储结构，结点结构为其中data数字的字符（即‘0’<=data<=‘9’）5、写出一个在带头结点的单链表上删除表中第i个结点的算法。

单链表的结点类型及单链表类型定义：typedef struct node{ DataType data；struct node *next；}Node, *LinkList;6、给出求二叉树的结点数的算法。

二叉树的二叉链表存储表示：typedef struct BiTNode{ DataType data;struct BiTNode *lchild,*rchild;}BiTNode, *BiTree;7. 写出一个删除单链表的表头结点和表尾结点的算法。

单链表的结点类型及单链表类型定义：typedef struct node{ DataType data；struct node *next；}Node, *LinkList;8、已知一带头结点的单链表，由头指针H指向，其结点的类型如下：typedef struct node{ elemtype data;struct node *next;}NODE,*NODEPTR;现要在链表中删除其关键字为aidkey的结点，其程序如下：int deletelm(NODEPTR H,keytype aidkey)/*若删除成功，则返回1，否则返回0*/{ NODEPTR pre,p;pre=H;p=H->next;while(p&&p->data.key!=aidkey){ pre=p;①;}if(p){ ②;free(p);return 1;}else return 0;}9、已知待排序的线性表的结构定义如下：#define MAXSIZE 200typedef int keytype;typedef struct{ keytype key;othertype other;}redtype;typedef struct{ redtype r[MAXSIZE];int length;}sqlist;其中L->r[0]用于作临时单元，数据从L->r[1]开始存放。

算法设计与分析试题及答案

1．按分治策略求解棋盘覆盖问题时，对于如图所示的24×24的特殊棋盘，共需要多少个L 型骨牌；并在棋盘上填写L 型骨牌的覆盖情况。

2．假设有7个物品，给出重量和价值。

若这些物品均不能被分割，且背包容量M ＝140，使用回溯方法求解此0-1背包问题。

请画出状态空间搜索树。

3．假设有7个物品，它们的重量和价值如下表所示。

若这些物品均可以被分割，且背包容量M＝140，使用贪心算法求解此背包问题。

请写出求解策略和求解过程。

W （35,30,50,60,40,10,25）p （10,40,30,50,35,40,30）4．在给出的电路板中，阴影部分是已作了封锁标记的方格，请按照队列式分支限界法在图中确定a 到b 的最短布线方案，要求布线时只能沿直线或直角进行，在图中标出求得最优解时各方格情况。

5．画出字符表的哈夫曼编码对应的二叉树。

6．已知1()*()i i k k ij r r A a +=，k =1，2，3，4，5，6，r 1=5，r 2=10，r 3=3，r 4=8，r 5=5，r 6=20，r 7=6，求矩阵链积A 1×A 2×A 3×A 4×A 5×A 6的最佳求积顺序。

7．给出城市网络图，售货员要从城市1出发，经过所有城市回到城市1，画出该问题的解空间树，描述出用优先队列式分支限界法求解时的搜索情况。

表示出优先队列、当前扩展结点等的变化情况。

8．依据优先队列式分支限界法，求从s 点到t 点的单源最短路径，画出求得最优解的解空间树。

一、假设有7个物品，它们的重量和价值如下表所示。

若这些物品均不能被分割，且背包容量M＝150，使用回溯方法求解此背包问题。

请写出状态空间搜索树（20分）。

答：按照单位效益从大到小依次排列这7个物品为：FBGDECA 。

将它们的序号分别记为1～7。

则可生产如下的状态空间搜索树。

其中各个节点处的限界函数值通过如下方式求得：【排序1分】5x =6x =7x =17分，每个节点1分】a ．1501154040305035190.62540-++++⨯=7(1,1,1,1,,0,0)8b. 1501154040305030177.560-++++⨯=7(1,1,1,1,0,,0)12c ．4040305010170++++=(1,1,1,1,0,0,1)d. 1501054040303530167.560-++++⨯=3(1,1,1,0,1,,0)4e. 150130404050353017560-++++⨯=1(1,1,0,1,1,,0)3f. 1501304040503510170.7135-++++⨯=4(1,1,0,1,1,0,)7g. 40405030160+++=(1,1,0,1,0,1,0)h. 1501404040353010146.8535-++++⨯=2(1,1,0,0,1,1,)7i.1501254030503530167.560-++++⨯=5(1,0,1,1,1,,0)12 j. 1501454030503530157.560-++++⨯=1(0,1,1,1,1,,0)12在Q 1处获得该问题的最优解为(1,1,1,1,0,0,1)，背包效益为170。

计算机算法设计与分析期末试题4套（含答案）

计算机算法设计与分析期末试题4套（含答案）（1）用计算机求解问题的步骤: 1问题分析2、数学模型建立3、算法设计与选择4、算法指标5、算法分析6、算法实现7、程序调试8、结果整理文档编制（2）算法定义：算法是指在解决问题时，按照某种机械步骤一定可以得到问题结果的处理过程（3）算法的三要素1操作2、控制结构3、数据结构算法具有以下5个属性：有穷性：一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成。

确定性：算法中每一条指令必须有确切的含义。

不存在二义性。

只有一个入口和一个出口可行性：一个算法是可行的就是算法描述的操作是可以通过已经实现的基本运算执行有限次来实现的。

输入：一个算法有零个或多个输入，这些输入取自于某个特定对象的集合。

输出：一个算法有一个或多个输出，这些输出同输入有着某些特定关系的量。

算法设计的质量指标：正确性：算法应满足具体问题的需求；可读性：算法应该好读，以有利于读者对程序的理解；健壮性：算法应具有容错处理，当输入为非法数据时，算法应对其作出反应，而不是产生莫名其妙的输出结果。

效率与存储量需求：效率指的是算法执行的时间；存储量需求指算法执行过程中所需要的最大存储空间。

一般这两者与问题的规模有关。

经常采用的算法主要有迭代法、分而治之法、贪婪法、动态规划法、回溯法、分支限界法利用迭代算法解决问题，需要做好以下三个方面的工作：一、确定迭代模型。

在可以用迭代算法解决的问题中，至少存在一个直接或间接地不断由旧值递推出新值的变量，这个变量就是迭代变量。

二、建立迭代关系式。

所谓迭代关系式，指如何从变量的前一个值推出其下一个值的公式（或关系）。

迭代关系式的建立是解决迭代问题的关键，通常可以使用递推或倒推的方法来完成。

三、对迭代过程进行控制。

在什么时候结束迭代过程？这是编写迭代程序必须考虑的问题。

不能让迭代过程无休止地重复执行下去。

迭代过程的控制通常可分为两种情况：一种是所需的迭代次数是个确定的值，可以计算出来；另一种是所需的迭代次数无法确定。

算法设计与分析打印资料

第一章求二个正整数的最大公约数。

main( ) {int a,b,t,i; input (a,b); t=1；for (i=2; i<=a and i<=b; i++) while (a mod i=0 and b mod i=0 ) {t=t*i; a=a/i; b=b/i;} print(t ,“is maximal common divisor”); }第二章fact(int n) { if (n=0 or n=1) return (1); else return (n*fact(n-1)); }第三章完数main( ) {int i,k,j,s,a[20]; for(i=1;i<=1000;i++){s=1; k=0; for(j=2;j<i;j++)if (i mod j)==0){s=s+j; a[k]=j; k++;}if(i==s){print(s, “it’s factors are :”,1);for(j=0;i<k;j++)print(“,”,a[k]);}}}编写算法：打印具有下面规律的图形。

15 28 6 310 9 7 4main( ) {int i,j,a[100][100],n,k; input(n); k=1; for(i=1;i<=n;i=i+1) for( j=1;j<=n+1-i;j=j+1) {a[i-1+j][j]=k; k=k+1;} for(i=1;i<=n;i=i+1) {print( “\n”); for( j=1;j<=i;j=j+1)print(a[i][j]); } } 汉罗塔hanoi (int n,char a,char b,char c) 1) if(n>0) 2) hanoi(n-1,a,c,b);3) 输出“Move dise” ,n.”from pile”,a,” to”b);4) haboi(n-1,c,b,a);5) endif}从低位到高位逐位输出f1(n) {while(n>=10) { print( n mod 10); n=n\10;} print(n);} 数字翻译称英文main( ) {int i,a[10], ind; long num1,num2;char eng[10][6]={“zero”,”one”,”two”,”three ”,” four”,” five”,”six”,”seven”,“eight”,”nine”}; print(“Input a num”);input(num1); num2=num1; ind =0;while (num2<>0) {a[ind]=num2 mod 10; ind= ind +1; num2=num2/10; }print(num1, “English_exp:”, eng[a[ind-1]]); for( i=ind-2;i>=0;i=i-1) print(“-”，eng[a[i]]); } 找钱问题main( ){int i,j,x,y,z,a,b[7]={0,50,20,10,5,2,1},s[7]; input(x,y); z=y-x;for(i=1;i<=6;i=i+1) {a=z\b[i]; s[i]=a; z=z-a*b[i];} print(y,”-”x,”=”,z:);for(i=1;i<=6;i=i+1) if (s[i]<>0) print(b[i], “----”, s[i]); }【例1】编程打印形如下规律的n*n方阵例如下图：使左对角线和右对角线上的元素为0,它们上方的元素为1,左方的元素为2,下方元素为3,右方元素为4,下图是一个符合条件的阶矩阵。

算法设计分析期中试题.pdf

算法设计分析期中试题.pdf《算法设计与分析》期中试卷一、叙述分治算法的基本思想及一般算法设计模式；二、叙述动态规划算法的基本步骤及动态规划算法的基本要素；三、改进课本P74的Lcs算法，使改进算法不用数组b亦可在O（m+n）的时间内构造最长公共序列；四、求下列函数的渐近表达式(1). 3n2+10n(2).n2/10+2n(3)21+1/n(4)logn3(5)10log3n五、对于下列各组函数发f（n）和g（n），确定f（n）=O(（g(n)）)或者f（n）= (（g(n)）)或者f（n）=θ(（g(n)）)，并简述理由(1). f（n）=logn2 , g(n)=logn+5;(2). f（n）=logn2 , g(n)= √n;(3), f（n）=n, g(n)= logn2;(4). f（n）=nlogn+n,g(n)=logn;(5). f（n）=10.g(n)=log10;(6). f（n）=log2n g(n)=logn(7). f（n）=2n g(n)= 3n;(8). f（n）=2n g(n)= 100n2;六、设a[0:n-1]是已排好序的数组，请改写二分搜索算法，使得当搜索元素x不再数组中时，返回小于x的最大元素位置i和大于x 的最小元素位置j。

当搜索元素在数组中时，i和j相同，均为x 在数组中的位置七、设a[0:n-1]是有n个元素的数组，k（0<=k<=n-1）是非负整数。

试设计一个算法将子数组a[0:k]与a[k+1:n-1]换位。

要求算法在最坏的情况下耗时O(n),且只用到O(1)的辅助空间。

八、在一个由元素组成的表中出现次数最多的元素称为众数。

试写一个寻找众数的算法，并分析其计算复杂性。

九、设计一个O(n2)时间的算法，找出由n个数组成的序列的最长单调递增子序列。

十、给定n中物品和一背包，物品i的重量是ω，体积是b i，其价值为v i ，背包的容量为C，容积为D。

数据结构算法设计题及答案

数据结构算法设计题及答案1、对带表头结点的有序单链表，编写算法向单链表中插入元素x，使其保持有序。

答案：typedef datatype int;struct node //结点结构{ datatype data;node * next;};//注：也可以用自然语言描述void insertOrder(node *head, datatype x) //统计{ node *s;p=head;while (p->next ->data<x)p=p->next;s=( node *)malloc(sizeof(node)) ;s->data=x;s->next= p->next;p->next=s;}2、对带表头结点的单链表，编写算法求单链表的长度。

答案：typedef datatype int;struct node //结点结构{ datatype data;node * next;};//注：也可以用自然语言描述int Length(node *head) // 求单链表的长度{ int num=0;node *p=head->next;while (p){num++ ;p=p->next;}return num;}3、试写出单链表的插入与删除算法，并用C编写相应的程序。

答案：typedef datatype int;struct node //结点结构{ datatype data;node * next;};单链表的插入参考算法：//在包含元素x的结点前插入新元素bvoid ins_linked_LList(node * head , datatype x, datatype b) { node *p, *q;p=new node ;//申请一个新结点p->d=b;//置新结点的数据域if (head==NULL)//原链表为空{ head=p; p->next=NULL; return;}if (head->d==x)//在第一个结点前插入{ p->next=head;head=p;return; }q=head;while ((q->next!=NULL)&&(((q->next)->d)!=x))q=q->next;//寻找包含元素x的前一个结点qp->next=q->next;q->next=p;//新结点p插入到结点q之后return;}单链表的删除参考算法：int del_linked_LList(node * head ,T x) //删除包含元素x的结点元素{ node *p, *q;if (head==NULL) return(0); //链表为空，无删除的元素if ((head->d)==x)//删除第一个结点{ p=head->next; delete head; head=p; return(1); }q=head;while ((q->next!=NULL)&&(((q->next)->d)!=x))q=q->next;//寻找包含元素x的前一个结点qif (q->next==NULL)return(0); //链表中无删除的元素p=q->next; q->next=p->next;//删除q的下一个结点pdelete p;//释放结点p的存储空间return(1);}4、对带表头结点的单链表，编写算法统计单链表中大于x的元素个数。

算法分析与设计复习题及参考答案

《算法分析与设计》课程复习资料一、名词解释：1.算法2.程序3.递归函数4.子问题的重叠性质5.队列式分支限界法6.多机调度问题7.最小生成树二、简答题：1.备忘录方法和动态规划算法相比有何异同？简述之。

2.简述回溯法解题的主要步骤。

3.简述动态规划算法求解的基本要素。

4.简述回溯法的基本思想。

5.简要分析在递归算法中消除递归调用，将递归算法转化为非递归算法的方法。

6.简要分析分支限界法与回溯法的异同。

7.简述算法复杂性的概念，算法复杂性度量主要指哪两个方面？ 8.贪心算法求解的问题主要具有哪些性质？简述之。

9.分治法的基本思想是什么？合并排序的基本思想是什么？请分别简述之。

10.简述分析贪心算法与动态规划算法的异同。

三、算法编写及算法应用分析题：1.已知有3个物品：(w1,w2,w3)=(12,10,6),(p1,p2,p3)=(15,13,10),背包的容积M=20，根据0-1背包动态规划的递推式求出最优解。

2.按要求完成以下关于排序和查找的问题。

①对数组A={15，29，135，18，32，1，27，25，5}，用快速排序方法将其排成递减序。

②请描述递减数组进行二分搜索的基本思想，并给出非递归算法。

③给出上述算法的递归算法。

④使用上述算法对①所得到的结果搜索如下元素，并给出搜索过程：18，31，135。

3.已知1()*()i i k k ij r r A a +=，k =1，2，3，4，5，6，r 1=5，r 2=10，r 3=3，r 4=12，r 5=5，r 6=50，r 7=6，求矩阵链积A 1×A 2×A 3×A 4×A 5×A 6的最佳求积顺序（要求给出计算步骤）。

4.根据分枝限界算法基本过程,求解0-1背包问题。

已知n=3,M=20，(w1,w2,w3)=(12,10,6),(p1,p2,p3)=(15,13,10)。

C语言算法设计题

4、设有一组关键字{19，01，23，14，55，20， 84，27，68，11，10，77}采用散列函数： H(key)=key%13，采用开放地址法的线性探测、二次探测和随机探测再散列方法解决冲突，试在 0~18的散列地址空间中对该关键字序列构造散列表。（随机探测再散列的下一地址计算公式为： d1=H(key), dj=(d1+R)%m，取伪随机序列R=3,54,11,36,19,…）
5、已知序列{70，83，100，65，10，32，7，9}，请给出采用插入排序法对该序列作升序排序时的每一趟的结果。 6、已知序列{10，18，4，3，6，12，1，9，15， 8}，请给出采用希尔排序法对该序列作升序排序时的每一趟的结果。（d=5,2,1） 7、已知序列{10，18，4，3，6，12，1，9，15， 8}，请给出采用归并排序法对该序列作升序排序时的每一趟的结果。
1.设计判断单链表中元素是否是递增的算法。 2.设计在单链表中删除值相同的多余结点的算法。 3.设计两个有序单链表的合并排序算法。 4.设计判断两个二叉树是否相同的算法。 5.设计计算二叉树中所有结点值之和的算法。 6.设计一个求结点x在二叉树中的双亲结点算法。
1、画出对长度为10的有序表进行折半查找的一棵判定树，并求其等概率时查找成功的平均查找长度。 2、设数据集合d={1,12,5,8,3,10,7,13,9}试完成下列各题：（1）依次取d中各数据，构造一棵二叉排序树bt; （2）如何依据此二叉树bt得到d的一个有序序列；（3）画出在二叉树bt中删除“12”后的树结构。 3、设关键字的输入序列为4、5、7、2、1、3、6，构造AVL树（AVL树的4种调整平衡操作各至少一次），画出其构造过程。
1、已知序列{17，18，60，40，7，32，73，65， 85}，请给出采用冒泡排序法对该序列作升序时的每一趟的结果。 2、已知序列{503，87，512，61，908，170， 897，275，653，462}，请给出采用快速排序法对该序列作升序排序时的每一趟的结果。 3、已知序列{503，87，512，61，908，170， 897，275，653，462}，请给出采用堆排序对该序列作降序排序 897，275，653，462}，请给出采用基数排序法对该序列作升序排序时的每一趟的结果。

(完整word版)算法设计与分析复习题目及答案

一。

选择题1、二分搜索算法是利用（ A ）实现的算法。

A、分治策略B、动态规划法C、贪心法D、回溯法2、下列不是动态规划算法基本步骤的是（ A ）。

A、找出最优解的性质B、构造最优解C、算出最优解D、定义最优解3、最大效益优先是（ A ）的一搜索方式。

A、分支界限法B、动态规划法C、贪心法D、回溯法4、在下列算法中有时找不到问题解的是（ B ）。

A、蒙特卡罗算法B、拉斯维加斯算法C、舍伍德算法D、数值概率算法5. 回溯法解旅行售货员问题时的解空间树是（ B ）。

A、子集树B、排列树C、深度优先生成树D、广度优先生成树6．下列算法中通常以自底向上的方式求解最优解的是（ B ）。

A、备忘录法B、动态规划法C、贪心法D、回溯法7、衡量一个算法好坏的标准是（C ）。

A 运行速度快B 占用空间少C 时间复杂度低D 代码短8、以下不可以使用分治法求解的是（D ）。

A 棋盘覆盖问题B 选择问题C 归并排序D 0/1背包问题9. 实现循环赛日程表利用的算法是（ A ）。

A、分治策略B、动态规划法C、贪心法D、回溯法10、下列随机算法中运行时有时候成功有时候失败的是（C ）A 数值概率算法B 舍伍德算法C 拉斯维加斯算法D 蒙特卡罗算法11．下面不是分支界限法搜索方式的是（ D ）。

A、广度优先B、最小耗费优先C、最大效益优先D、深度优先12．下列算法中通常以深度优先方式系统搜索问题解的是（ D ）。

A、备忘录法B、动态规划法C、贪心法D、回溯法13.备忘录方法是那种算法的变形。

（ B ）A、分治法B、动态规划法C、贪心法D、回溯法14．哈弗曼编码的贪心算法所需的计算时间为（ B ）。

A、O（n2n）B、O（nlogn）C、O（2n）D、O（n）15．分支限界法解最大团问题时，活结点表的组织形式是（ B ）。

A、最小堆B、最大堆C、栈D、数组16．最长公共子序列算法利用的算法是（ B ）。

A、分支界限法B、动态规划法C、贪心法D、回溯法17．实现棋盘覆盖算法利用的算法是（ A ）。

数据结构算法设计题及答案

数据结构算法设计题及答案一、题目设计一个算法，用于在一个未排序的整数数组中查找第二小的元素。

二、算法思路首先，我们可以通过遍历数组找到最小的元素。

然后，再次遍历数组，排除已经找到的最小元素，找到剩余元素中的最小元素，即为第二小的元素。

三、算法实现（使用 Python 语言）｀｀｀pythondef find_second_smallest(arr)：min1 ＝ float(＇inf'）min2 ＝ float(＇inf'）for num in arr:if num ＜ min1:min2 ＝ min1min1 ＝ numelif num ＜ min2 and num!＝ min1:min2 ＝ numreturn min2｀｀｀四、示例输入与输出假设我们有数组｀5, 3, 8, 1, 9` 。

当我们调用｀find_second_smallest(5, 3, 8, 1, 9)｀时，算法首先找到最小的元素｀1` ，然后在剩余元素｀5, 3, 8, 9` 中找到最小的元素｀3` ，所以返回｀3` 。

五、题目给定一个链表，判断链表中是否存在环。

六、算法思路我们可以使用快慢指针的方法来解决这个问题。

慢指针每次移动一步，快指针每次移动两步。

如果在移动过程中，快慢指针相遇，那么就说明链表中存在环；如果快指针到达链表末尾，那么就说明链表中不存在环。

七、算法实现（使用 Python 语言）｀｀｀pythonclass ListNode:def ＿_init__(self, val=0, next=None)：selfval ＝ valselfnext ＝ nextdef has_cycle(head)：slow ＝ headfast ＝ headwhile fast and fastnext:slow ＝ slownextfast ＝ fastnextnextif slow ＝＝ fast:return Truereturn False｀｀｀八、示例输入与输出假设我们有一个链表｀1 ＞ 2 ＞ 3 ＞ 4 ＞ 5 ＞ 2` （其中 5 指向 2 形成环）。

算法设计题目.docx

第2章1、大整数乘法的O(nm log(3/2))算法给定2个大整数u和v，它们分别有m位和n位数字，且mn。

用通常的乘法求uv的值需要O(mn)时间。

可以u和v均看作是有n位数字的大整数，用教材第2章介绍的分治法，在O(n log3)时间内计算uv的值。

当m比n小得多时，用这种方法就显得效率不够高。

试设计一个算法，在上述情况下用O(nm log(3/2))时间求出uv的值。

2、O(1)空间子数组换位算法设a[0:n-1]是一个有n个元素的数组，k(1kn-1)是一个非负整数。

试设计一个算法将子数组a[0:k-1]与a[k+1:n-1]换位。

要求算法在最坏情况下耗时O(n)，且只用到O(1)的辅助空间。

3、段合并排序算法如果在合并排序算法的分割步骤中，将数组a[0:n-1]划分为个子数组，每个子数组中有O()个元素。

然后递归地对分割后的子数组进行排序，最后将所得到的个排好序的子数组合并成所要的排好序的数组a[0:n-1]。

设计一个实现上述策略的合并排序算法，并分析算法的计算复杂性。

4、合并排序算法对拨给元素存储于数组和存储于链表中的2种情形，写出合并排序算法。

5、非增序快速排序算法如何修改QuickSort才能使其将输入元素按非增序排序？第三章1、整数线性规划问题考虑下面的整数线性规划问题试设计一个解此问题的动态规划算法，并分析算法的计算复杂性。

2、Ackermann函数Ackermann函数A(m,n)可递归地定义如下：A（m，n）=试设计一个计算A(m,n)的动态规划算法，该算法只占用O(m)空间。

3、独立任务最优调试问题问题描述：用2台机A和B处理n个作业。

设第i个作业交给机器A处理时需要时间ai ，若由机器B来处理，则需要时间bi。

由于各作业的选战和机器的性能关系，很可能对于某些i，有ai≥bi，而对于某些j，j≠i，有ai <bj。

既不能将一个作业分开由2台机器处理，也没有一台机器能同时处理2个作业。

算法实验设计题

在一个按照东西和南北方向划分成规整街区的城市里，n 个居民点散乱地分布在不同的街区中。

用x 坐标表示东西向，用y 坐标表示南北向。

各居民点的位置可以由坐标(x,y)表示。

街区中任意2 点(x 1,y 1)和(x2,y2)之间的距离可以用数值|x1-x2|+|y 1-y2|度量居民们希望在城市中选择建立邮局的最佳位置，使n 个居民点到邮局的距离总和最小。

编程任务：给定n 个居民点的位置,编程计算n 个居民点到邮局的距离总和的最小值。

´数据输入：第 1 行是居民点数n，1<n<=10000。

接下来n 行是居民点的位置，每行2 个整数x 和y，- 10000<=x ，y <=10000。

结果输出:n 个居民点到邮局的距离总和的最小值。

例如输入输出5 101 22 21 33 -23 3设计递归算法求解如下多项式：均分纸牌（NOIP2002tg）[问题描述] 有N 堆纸牌，编号分别为1，2，…, N。

每堆上有若干张，但纸牌总数必为N 的倍数。

可以在任一堆上取若干张纸牌，然后移动。

移牌规则为：在编号为 1 堆上取的纸牌，只能移到编号为 2 的堆上；在编号为N 的堆上取的纸牌，只能移到编号为N-1 的堆上；其他堆上取的纸牌，可以移到相邻左边或右边的堆上。

现在要求找出一种移动方法，用最少的移动次数使每堆上纸牌数都一样多。

例如N=4，4 堆纸牌数分别为：①9 ②8 ③17 ④ 6移动3次可达到目的：从③取 4 张牌放到④（9 8 13 10）-> 从③取 3 张牌放到②（9 11 10 10）-> 从②取1 张牌放到①（10 10 10 10）。

[输入]：键盘输入文件名。

文件格式：N（N 堆纸牌，1 <= N <= 100）A1 A2 …An （N 堆纸牌，每堆纸牌初始数，l<= Ai <=10000）[输出]：输出至屏幕。

格式为：所有堆均达到相等时的最少移动次数。

数据结构(本科)期末综合练习五(算法设计题)

数据结构（本科）期末综合练习五（算法设计题）1. 设有一个线性表 (e0, e1, …, e n-2, e n-1) 存放在一个一维数组A[arraySize]中的前n个数组元素位置。

请编写一个函数将这个线性表原地逆置，即将数组的前n个元素内容置换为 (e n-1, e n-2, …, e1, e0)。

函数的原型为：template<class Type>void inverse ( Type A[ ], int n );2. 试编写一个函数，在一个顺序表A中找出具有最大值和最小值的整数。

函数的原型如下所示，原型的参数表中给出顺序表对象为A，通过算法执行，从参数表中的引用参数Max中得到表中的最大整数，Min中得到表中的最小整数。

注意，函数中可使用顺序表的两个公有函数：Length( ) 求表的长度；getData(int k) 提取第k个元素的值。

#include “SeqList.h”template <class T> void FindMaxMin ( SeqList<int>& A, int& Max, int& Min );3. 设有两个整数类型的顺序表A（有 m个元素）和B（有n个元素），其元素均以升序排列。

试编写一个函数，将这两个顺序表合并成一个顺序表C，要求C的元素也以升序排列（表中允许元素重复）。

函数的原型如下所示。

原型中的参数表给出参加运算的三个顺序表A、B与C。

从C中得到执行结果。

函数中用到顺序表的4个公有函数：Length( ) 求表的当前长度；maxLength( ) 求表的最大允许长度；getData(int k) 提取第k个元素的值；setData(int k, int val) 修改第k个元素的值为val。

template<class T>void merge(SeqList<int>& A, SeqList<int>& B, SeqList<int>& C);4. 编写一个函数frequency，统计在一个输入字符串中各个不同字符出现的频度。

算法设计与分析(试题A卷)

四川师范大学成教×××专业×××层次半脱产形式期末考试期末试卷第1页( 共6页)《算法设计与分析》课程试卷(A)答卷说明：1、考试方式闭卷2、满分100分一、单项选择题（每小题3分，共30分）1、动态规划算法的基本要素为（）。

A 、最优子结构性质与贪心选择性质B 、重叠子问题性质与贪心选择性质C 、最优子结构性质与重叠子问题性质D.、预排序与递归调用2、算法分析中，记号O 表示（），记号Ω表示（），记号Θ表示（）。

A 、渐进下界B 、渐进上界C 、非紧上界D 、紧渐进界E 、非紧下界3、以下关于渐进记号的性质是正确的有：（）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))=⇔=4、下列算法中通常以自底向上的方式求解最优解的是（）。

四川师范大学成教××专业××层次××形式期末考试 ××试卷第2页( 共6页) A 、备忘录法 B 、动态规划法 C 、贪心法 D 、回溯法5、衡量一个算法好坏的标准是（）。

A 、运行速度快B 、占用空间少C 、时间复杂度低D 、代码段6、实现棋盘覆盖算法利用的算法是（）。

A 、分治法B 、动态规划法C 、贪心法D 、回溯法7、下面关于NP 问题说法正确的是（）。

A 、NP 问题都是不可能解决的问题B 、P 类问题包含在NP 类问题中C 、NP 完全问题是P 类问题的子集D 、NP 类问题包含在P 类问题中8、矩阵连乘问题的算法可由（）设计实现。

A 、分支界限算法B 、动态规划算法C 、贪心算法9、（）是贪心算法与动态规划算法的共同点。

常用算法设计方法(2019年下-打印版本有答案--改革版本)

第1节计算机算法概述 (1)1.1算法的五个特性 (1)1.2算法设计的要求 (1)1.3算法效率的度量 (1)第2节各种常规算法 (2)2.1迭代法 (2)2.2穷举搜索法 (3)2.3递推法 (3)2.4递归法 (3)2.5分治法 (4)2.5.1 分治法思想 (4)2.5.2 分治法时间复杂度计算 (5)2.6动态规划法 (6)2.7回溯法 (8)2.8贪心法 (10)2.9分支限界法 (10)2.10概率算法 (11)2.11字符串的模式匹配 (11)第3节附录部分 (12)3.1使用递推法求N的阶乘程序代码 (12)第1节计算机算法概述计算机算法是对特定问题求解步骤的描述，它是指令的有限序列.为解决某问题的算法与为该问题编写的程序含义是相同的. 常用的表示算法的语言有：自然语言、流程图、盒图、程序设计语言和伪代码.1.1 算法的五个特性1. 有限性：算法必须在执行有限条指令之后结束，每条指令执行的时间也必须是有限的.2. 确定性：算法中每一条指令必须有确切的含义，读者和计算机在理解时不会产生二义性，并且在相同条件下，相同的输入只能得到相同的输出.3. 可行性：算法能把问题真正的解决.即不能是理论正确但无法在计算机上实现的算法.4. 输入：一个算法有零个或多个输入.1.2 算法设计的要求1. 正确性：算法应当满足具体问题的需求.2. 可读性：算法应该能让人读懂，能被计算机运行.3. 健壮性：算法应该具有容错处理能力，不容易被击垮.4. 高效率与低存储量要求：效率指程序的执行时间（越短越好），算法要占用计算机一定的存储量（越小越好）.1.3 算法效率的度量1. 时间复杂度根据不同的输入，将算法的时间复杂度分为三种情况：(1) 最佳情况：使算法执行时间最少的输入.一般不进行算法在最佳情况下的时间复杂度分析.(2) 最坏情况：使算法执行时间最多的输入.一般会进行算法在最坏时间复杂度的分析，因为最坏情况是在任何输入下运行时间的一个上限，而且对于某些算法来说，最坏情况是相当频繁的.(3) 平均情况：算法的平均运行时间，可按三个步骤进行分析：将所有的输入按其执行时间分类；确定每类输入发生的概率；确定每类输入的执行时间.(4) 时间复杂度的表示算法时间复杂度符号O 、Ω、Θ的定义分别如下.⏹ O 记号：给出一个函数的渐进上界.给定一个函数g(n)，O(g(n))表示为一个函数集合的{f(n)：存在正常数c 和n0，使得对所有的n ≥n0，有O ≤f(n)≤c ·g(n)}.⏹ Ω记号：给出一个函数的渐进下界.给定一个函数g(n),Ω(g(n))表示为一个函数集合的{f(n)：存在正常数c 和n0，使得对所有的n ≥n0，有O ≤c ·g(n)≤f(n).⏹ Θ记号：给出一个函数的渐进上界和下界，即渐进确界.给定一个函数g(n)，Θ(g(n))表示为一个函数集合{f(n)：存在正常数c 1、c 2和n 0，使得对所有的n ≥n0，有O ≤c 1·g(n)≤f(n)≤c 2·g(n)}.常用大O 记法，假如一个程序的实际执行时间为T （n ）= 2n 3+n 2+5，则T （n ）=O （n 3）. (5) 时间复杂度常用表示方法⏹ 大O 记法:假如一个程序的实际执行时间为T （n ）= 2n 3+n 2+5，则T （n ）=O （n 3），只用最高的次幂表示.⏹ O(1)：当算法耗费的时间没有达到n 这个数据级别时，就使用O(1)表示（其中的“1”并非表示数量1，而表示时间未至n 这个数量级）.常见的时间复杂度如图 1.1所示.)2()()()log ()()(log )1(3222nO n O n O n n O n O n O O <<<<<<●(2012年上)以下关于渐进符号的表示中，不正确的是 (62) .(62)A.n 2= (n 2) B.n 2=O(n 2) C.n 2=O(n) D.n 2=O(n 3) ●(2004年下)下面函数中渐进时间最小的是(53).2. 空间复杂度一个算法的空间复杂度是指程序运行从开始到结束所需的存储量.主要包含算法自身实现所需要的辅助存储空间，不包含程序中原存储数据的空间.⏹固定空间：在硬盘上的存储空间.交换A[i]和A[j](65)A. (n)和(n) B．(1)和(n) C. (n)和(1) D．(1)和(1)●(2013年上)采用顺序表和单链表存储长度为n的线性序列，根据序号查找元素，其时间复杂度分别为(51).第2节各种常规算法2.1 迭代法思想：从某个点出发，通过某种方式求出下一个点，使得其离要求的点（方程的解）更近一步；当两点之差接近到可接受的精度范围时，就认为找到了问题的解.注意：如果方程无解或者迭代方法不够适用，那么近似根序列将不会收敛，迭代过程会成为“死循环”.所以使用迭代法之前要进行是否有解的判断，并且限制迭代的次数；而方程即使有解，也要选择合适的迭代公式，否则迭代失败.2.2 穷举搜索法思想：对可能的众多候选解按某种顺序进行逐一枚举和检验，并从中找出那些符合要求的候选解作为问题的解.特点：这种方法通常采用多重循环（循环次数取决于变量个数）来实现，对每个变量的每个值都测试是否满足所给定的条件，如果满足则认为找到问题的一个可行解.缺点：只能解决候选解个数非常有限且容易枚举这些候选解的问题.例子：找出n个自然数(1,2,3,…,n)中r个数的组合，要求r为3，且第一位数大于第二位数，第二位数大于第三位数.2.3 递推法思想：设要求解的问题规模为N，当N≤某个常数C时，解或为已知，或能非常方便地得到解.能采用递推法构造算法的问题有重要的递推性质：当得到问题规模为i-1的解后，由问题的性质，能从已求得的规模为1、2、3…、i-1的一系列解，构造出问题规模为i的解.这样，程序可从i=0或i=1出发，重复地，由已知的i-1规模的解，通过递推，获得规模为i的解，直至规模为n的解.递推法典型用法是求整数的阶乘问题.求n！可转换为(n-1)!*n，以下是使用递推法求解整数5的阶乘的算法描述：(1)求出1的阶乘结果为1（1的阶乘结果是已知的）；(2)根据1的阶乘结果递推2的阶乘，即2！=1！*2;(3)根据2的阶乘结果递推3的阶乘，即3！=2！*3;(4)根据3的阶乘结果递推4的阶乘，即4！=3！*4;(5)根据4的阶乘结果递推5的阶乘，即5！=4！*5;递推法特点：执行效率高，能解决有前向相关性的问题，但是要求前向相关顺序确定而且个数不多的问题.任何能使用递推法解决的问题，都能使用递归法解决，但反之不然.2.4 递归法递归描述的算法通常有这样的特征：为求解规模为N的问题，设法将它分解成规模较小的一些问题，然后从这些小问题的解方便地构造出大问题的解，并且这样规模较小的问题也能采用同样的分解和综合方法，分解成规模更小的问题，并从这些更小问题的解构造出其分解之前问题的解.特别地，当规模N≤C(C为常数)时，能直接得到解.阶乘函数可递归地定义如图 2.1所示：图 2.1 阶乘递归式阶乘函数的自变量n的定义域是非负整数.递归式的第一式给出了这个函数的一个初始值，是非递归定义的.每个递归函数都必须有非递归定义的初始值，否则，递归函数就无法计算.递归式的第二式是用较小自变量的函数值来表示较大自变量的函数值的方式来定义n的阶图 2.2 求3！的递归图特点:由于递归程序需要调用工作栈，故其运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多.递归程序分为递推和回归两个过程：⏹ 递推过程：把较复杂的问题的求解推到比原来问题简单一些的问题的求解； ⏹ 回归阶段：当获得最简单情况的解后，逐级返回，依次获得稍复杂问题的解. Fibonacci 数列和背包问题等都是递归算法的典型应用. 递推法和递归法的关系：任何能使用递推法解决的问题，都能使用递归法解决，反之不成立.因为某些递归算法所要求的子问题的形式，2.5 分治法2.5.1 分治法思想思想：将一个难以直接解决的大问题，分解成一些规模较小的相同问题，以便各个击破，分而治之.如果规模为n 的问题可以分解成k 个子问题，1<k<=n,且这些子问题互相独立且与原问题相同，然后递归求解这些子问题，最后将各子问题的解合并成原大问题的解.Hanoi 塔问题、比赛日程安排是该算法的典型应用场所.例子：最大子段和问题.给定由n 个整数(可能为负整数)组成的序列a 1、a 2、a 3、…、a n ,求该序列形如∑=jik ka的子段和的最大值.当所有整数均为负整数时定义其最大子段和为0，依次定义，所求的最优值为:⎪⎭⎪⎬⎫⎪⎩⎪⎨⎧∑=<=<=<=j ik ka n j i max 1,0max ,例如，当(a 1, a 2, a 3, a 4, a 5,a 6)=( -2,11,-4,13,-5,-2)时，最大子段和为：2042=∑=k ka，如果将所给的序列a[1:n]分为长度相等的两端a[1:n/2]和a[n/2+1:n],分别求出这两端的最大子段和，则a[1:n]的最大子段和有3种情形：(1) a[1:n]的最大子段和与a[1:n/2]的最大子段和相同； (2) a[1:n]的最大子段和与a[n/2+1:n]的最大子段和相同； (3) a[1:n]的最大子段和为∑=jik ka，且1<=i<= n/2, n/2+1<=j<= n ；(1)和(2)这两种情形可递归求得.对于情形（3），容易看出a[n/2]和a[n/2+1]在最优子序列中.容易得出情形（3）的最优值为Sum ： s1=∑=<=<=2/2/1max n ik k n i as2=∑+=<=<=+in k k n i n a12/12/maxSum = s1+s2;2.5.2 分治法时间复杂度计算（62）A.Θ（nlg n） B.Θ（nlgn） C.Θ（n） D.Θ（n）解析：●(2011年下)在有n个无序无重复元素值的数组中查找第i小的数的算法描述如下：任意取一个元素r，用划分操作确定其在数组中的●(2008年上)斐波那契(Fibonacci)数列可以递归地定义为：(63)2.6 动态规划法1.基本思想动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从子问题的解中得到原问题的解.与分治法不同的是，适合用于动态规划法求解的问题，经分解得到的子问题往往不是独立的，若用分治法来解决这类问题，则分解得到的重复子问题太多.动态规划算法通常用于求解具有某种最优性质的问题，在这类问题中，可能会有许多可行解，每一个解都对应一个值，我们希望找到具有最优值（最大或最小）那个解，设计一个动态规划算法，通常可按以下几个步骤进行：(1) 找出最优解的性质，并刻画其结构特征 (2) 递归的定义最优值；(3) 以自底向上的方式计算出最优值；(4) 根据计算最优值时得到的信息，构造一个最优解.步骤（1）－（3）是动态规划算法的基本步骤，在只需要求出最优值的情形下步骤4可以省略，若需要求出问题的一个最优解，则必须执行步骤（4）.此时，在步骤3中计算最优值时，通常需记录更多的信息，以便在步骤4中根据所记录的信息，快速构造出一个最优解. 2. 动态规划适合解决的问题(1) 最优子结构：如果一个问题的最优解中包含了其子问题的最优解，就说该问题具有最优子结构.当一个问题具有最优子结构时，可考虑动态规划算法，但贪心策略也可能使用.(2) 重叠子问题：在用分治法求解时，有些子问题被重复求解许多次，如果我们能够保存已解决的子问题的解，而在需要时再找出已求得的解，这样就可以避免大量的重复计算，从而得到更高效的算法.为了达到这个目的，可以用一个表来记录所有已解决的子问题的答案.不管该子问题以后是否被用到，只要它被计算过，就将其结果记录入表中，这就是动态规划算法的基本思想.我们同样考虑最大子段和问题，设∑=<=<==ijk k ij a bi 1max，即bi 是a 序列以a i 结尾的子段和中，最大的那个子段和.则原问题的解maxSum=max{b i }.在求解b i 的时候，若b i -1<=0，则以a i 结尾的最大子段和不应该包含ai 之前的元素，即b i =a i .否则，b i =a i +b i -1.2.7 回溯法⏹有“通用的解题法”之称，也称为试探法，用它可以系统地搜索一个问题的所有解或任一解.⏹回溯法是一个既有系统性又带有跳跃性的搜索算法.它在包含问题所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树，算法搜索至解空间树的任一节点时，总是先判断该点是否肯定不包含问题的解.如果肯定不包含，则跳过以该节点为根的子树的系统搜索，逐层向其祖先节点回溯，否则，进入该子树，继续按深度优先的策略进行搜索.回溯法在求问题的所有解时，要回溯到根，且根节点的所有子树都已被搜索遍才结束.而在求解任一解时，只要搜索到任一解就可以结束.这种以深度优先的方式系统地搜索问题的解的算法称为回溯法，它适用于解一些组合数较大的问题.1.问题的解空间应用回溯法解问题时，首先应明确定义问题的解空间.例如，对于有n种可选物品的0-1背包问题，其解空间由长度为n的0-1向量组图 2.3 0-1背包问题的解空间树2.回溯法的基本思想确定了解空间的组织结构后，回溯法就从开始节点（根节点）出发，以深度优先的方式搜索整个解空间.这个开始节点就成为一个活节点，同时也成为当前的扩展节点.在当前的扩展节点处，搜索向纵深方向移至一个新节点，这个新节点就成为一个新的活节点，并成为当前扩展节点.如果在当前扩展节点处不能再向纵深方向移动，则当前的扩展节点就成为死节点.换句话说，这个节点不再是一个活节点.此时，应往回移动（回溯）至最近的一个活节点处，并使这个节点成为当前的扩展节点.回溯法即以这种工作方式递归地在解空间中搜索，直至找到所要求的解或解空间中已无活节点时为止.特例：用回溯法解决0-1背包问题问题描述：对于n＝3时的0-1背包问题，考虑下面的具体实例：w={16,15,15} p={45,25,25},c=30.其中w表示物品的重量，p表示物品的价值，c表示背包能够容纳的最大重量，请问怎么进行物品装包，使得背包没有被撑破，而又获得最大的价值？首先从根节点开始搜索其解空间.具体过程看课堂演示！！运用回溯法解题通常包含以下3个步骤：(1)针对所给问题，定义问题的解空间(2)确定易于搜索的解空间结构(3)以深度优先的方式搜索解空间(4)回溯法搜遍整个解空间，最后得到最优解.N皇后问题也是回溯方法的典型应用.注意：背包问题和0-1背包问题是不同的，0-1背包问题表示一个物体要么不放进背包，要么整体放进背包，物体不能切割；而背包2.8 贪心法贪心法是一种不追求最优解，只希望得到较为满意的解的方法.贪心法一般可以快速得到满意的解，因为它省去了为找最优解要穷尽所有可能解而必须耗费的大量时间.贪心法常以当前情况为基础作最优选择，而不考虑各种可能的整体情况，所以贪心法不要回溯.例如平时购物找钱时，为使找回的零钱硬币最少，不考虑找零钱所有的各种方案，而是从最大面值的币种开始，按递减的顺序考虑各种币种，先尽量用大面值的币种，当不足大面值币种的金额时才去考虑下一种较小面值的币值.这就是采用贪心法，这种方法在这里总是最优，是因为银行对其发行的硬币种类和硬币面值的巧妙安排.如果只有面值分别为1，5和11单位的硬币，而希望找回总额为15单位的硬币.按贪心算法，应找1个11单位面值的硬币和4个1单位面值的硬币，共找回5个硬币.但最优的解答应是3个5单位面值的硬币.(63)A．分治B．动态规划C．贪心D．回溯(64)A.(n2) B.(n) C.(nlgn) D.(1)●(2010年下)（65）不能保证求得0-1背包问题的最优解.⏹第i个物品不装入背包，此时最优解的值就是子问题KNAP(1,i-1,X)的最优解的效益值，即为：f i-1（X）2.9 分支限界法分支限界法类似于回溯法，也是一种在问题的解空间树T上搜索问题解的算法.但在一般情况下，分支限界法与回溯法的求解目标不同.回溯法的求解目标是找出T中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解.由于求解目标不同，导致分支界限法与回溯法在解空间树T上的搜索方式也不相同.回溯法以深度优先的方式搜索解空间树T，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间树T.分支限界法的搜索策略是，每一个活节点只有一次机会成为扩展节点.活节点一旦成为扩展节点，就一次性产生其所有儿子节点.在这些儿子节点中，凡是导致不可行解或非最优解的儿子节点被舍弃，其余儿子节点被加入活节点表中，此后，从活节点表中取下一节点成为当前扩展节点，并重复上述节点扩展过程.这个过程一直持续到所需的解或活节点表为空时为止.分支限界法已被利用来解决了大量离散最优化的实际问题.问题描述：对于n＝3时的0-1背包问题，考虑下面的具体实例：w={16,15,15} p={45,25,25},c=30.其中w表示物品的重量，p表示物品的价值，c表示背包能够容纳的最大重量，请问怎么进行物品装包，使得背包没有被撑破，而又获得最大的价值？2.10 概率算法概率算法的一个基本特征是对所求解问题的同一实例用同一概率算法求解两次，可能得到完全不同的效果.这两次求解所需的时间甚至所得到的结果可能有相当大的差别.有四种概率算法：1.数值概率算法：常用于数值问题的求解.这种算法所得到的往往是近似解，且近似解的精度随计算时间的增加而不断提高.但多数情况下只能得到近似解（满意解），得不到精确解.2.蒙特卡罗算法：用于求问题的精确解，但这个解未必是正确的.求得正确解的概率依赖于算法所用的时间.算法所用的时间越多，得到正确解的概率越高.缺点是：无法判断所得到的解是否正确.3.拉斯维加斯算法：得出问题的正确解，此算法一旦得出结果，这个结果肯定是正确解.找到正确解的概率随着它所用的计算时间的增加而提高.4.舍伍德算法：总能求得问题的一个解，且所求得的解总是正确的.当一个确定性算法在最坏情况下的计算复杂度与其在平均情况下的计算复杂度有较大差别时，可在这个确定性算法中引入随机性将它改造成一个舍伍德算法，消除或减少问题的好坏实例间的这种差别.舍伍next函数值为(58) .(58)A.0123123 B.0123210 C.0123432 D.01234561～7.此题关键是理解next[j]=max{k|1<k<j, “p p…p”=“p p…p”}，next[j]的值其实是求一个满足条件1<k<j且1.当j=1时，根据题意next[j]=next[1]=0;故next函数值为0；2.当j=2时，根据题意next[2]= max{k|1<k<2,“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”}，易知没有满足条件1<k<2的k的值，故只能next[2]=1(其他情况)；到此，next函数值为01(包含j=1时的next值)；3.当j=3时，根据题意next[3]=max{k|1<k<3,“p1p2…p k-1”=“p3-k+1p3-k+2…p3-1”}，易知满足条件1<k<3的k值为2.当k值为2时，“p1…p2-1”部分为“p1”，即字符串“a”；“p3-2+1…p3-1”部分为“p3-2+1…p3-1”为“p2”，即字符串“a”；此时可知当k=2时，满足1<k<3且“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”，则2可留在集合中，此时集合中只有2，故next[3]= max{2}=2.到此为止，next函数值为012(包含j=1、2时的next值)；4.当j=4时，根据题意next[4]=max{k|1<k<4,“p1p2…p k-1”=“p4-k+1p4-k+2…p4-1”}，易知满足条件1<k<4的k值为2、3.当k值为2时，“p1…p2-1”部分为“p1”，即字符串“a”；“p4-2+1…p4-1”部分为“p3…p3”为“p3”，即字符串“a”；此时可知当k=2时，满足1<k<4且“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”，则2可留在集合中；当k值为3时，“p1…p3-1”部分为“p1p2”，即字符串“aa”；“p4-3+1…p4-1”部分为“p2…p3”为“p2p3”，即字符串“aa”；此时可知当k=3时，满足1<k<4且“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”，则3可留在集合中；目前，集合中有两个数2与3，故next[4]=max{2,3}=3；到此，next 函数值为0123(包含j=1、2、3时的next值)；5.当j=5时，根据题意next[5]=max{k|1<k<5,“p1p2…p k-1”=“p5-k+1p5-k+2…p5-1”}，易知满足条件1<k<5的k值为2、3、4.当k值为2时，“p1…p2-1”部分为“p1”，即字符串“a”；“p5-2+1…p5-1”部分为“p4…p4”为“p4”，即字符串“b”；此时可知当k=2时，满足1<k<5但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则2不能留在集合中；当k值为3时，“p1…p3-1”部分为“p1p2”，即字符串“aa”；“p5-3+1…p5-1”部分为“p3…p4”为“p3p4”，即字符串“ab”；此时可知当k=3时，满足1<k<5但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则3不能留在集合中；当k值为4时，“p1…p4-1”部分为“p1p2p3”，即字符串“aaa”；“p5-4+1…p5-1”部分为“p2…p4”为“p2p3p4”，即字符串“aab”；可知当k=4时，满足1<k<5但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则4不能留在集合中；到此，找不到满足1<k<5且“p1p2…p k-1”=“p5-k+1p5-k+2…p5-1”条件的k值，故next[5]为1(其他情况)，next函数值为01231(包含j=1、2、3、4时的next值)；6.当j=6时，根据题意next[6]=max{k|1<k<6,“p1p2…p k-1”=“p6-k+1p6-k+2…p6-1”}，易知满足条件1<k<6的k值为2、3、4、5.当k值为2时，“p1…p2-1”部分为“p1”，即字符串“a”；“p6-2+1…p6-1”部分为“p5…p5”为“p5”，即字符串“a”；此时可知当k=2时，满足1<k<6和“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则2留在集合中；当k值为3时，“p1…p3-1”部分为“p1p2”，即字符串“aa”；“p6-3+1…p6-1”部分为“p4…p5”为“p4p5”，即字符串“ba”；此时可知当k=3时，满足1<k<6但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则3不能留在集合中；当k值为4时，“p1…p4-1”部分为“p1p2p3”，即字符串“aaa”；“p6-4+1…p6-1”部分为“p3…p4”为“p3p4p5”，即字符串“aba”；可知当k=4时，满足1<k<6但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则4不能留在集合中；当k值为5时，“p1…p5-1”部分为“p1p2p3p3”，即字符串“aaab”；“p6-5+1…p6-1”部分为“p2…p5”为“p2p3p4p5”，即字符串“aaba”；可知当k=5时，满足1<k<6但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则5不能留在集合中；到此，集合中有一个数2，故next[6]=max{2}=2；则next函数值为012312(包含j=1、2、3、4、5时的next值)；7.当j=7时，根据题意next[7]=max{k|1<k<7,“p1p2…p k-1”=“p7-k+1p7-k+2…p7-1”}，易知满足条件1<k<7的k值为2、3、4、5、6.当k值为2时，“p1…p2-1”部分为“p1”，即字符串“a”；“p7-2+1…p7-1”部分为“p6…p6”为“p6”，即字符串“a”；此时可知当k=2时，满足1<k<7和“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则2留在集合中；当k值为3时，“p1…p3-1”部分为“p1p2”，即字符串“aa”；“p7-3+1…p7-1”部分为“p5…p6”为“p5p6”，即字符串“aa”；此时可知当k=3时，满足1<k<7和“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则3留在集合中；当k值为4时，“p1…p4-1”部分为“p1p2p3”，即字符串“aaa”；“p7-4+1…p7-1”部分为“p4…p5”为“p4p5p6”，即字符串“baa”；可知当k=4时，满足1<k<7但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则4不能留在集合中；当k值为5时，“p1…p5-1”部分为“p1p2p3p4”，即字符串“aaab”；“p7-5+1…p7-1”部分为“p3…p6”为“p3p4p5p6”，即字符串“abaa”；可知当k=5时，满足1<k<7但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则5不能留在集合中；当k值为6时，“p1…p6-1”部分为“p1p2p3p4p5”，即字符串“aaaba”；“p7-6+1…p7-1”部分为“p2…p6”为“p2p3p4p5p6”，即字符串“aabaa”；可知当k=6时，满足1<k<7但不满足“p1p2…p k-1”=“p j-k+1p j-k+2…p j-1”条件，则6不能留在集合中；到此，集合中有两个数2与3，故next[7]=max{2，3}=3；则next函数值为0123123(包含j=1、2、3、4、5、6时的next值).串“abaabaca”，其next函数值序列为（57）.（57）A.01111111 B.01122341 C.01234567 D.01122334第3节附录部分3.1 使用递推法求n的阶乘程序代码例子：对给定的n(n<=100),计算并输出k的阶乘k!(k=1,2,3,…,n)的全部有效数字.由于要求的整数可能大大超出一般整数的位数，程序用一维数组存储长整数，存储长整数数组的每个元素只存储长整数的一位数字.如有m位长整数N用数组a[]存储：N=a[m]*10m-1+a[m-1]*10m-2+…+a[2]*101+a[1]*100用a[0]存储长整数N的位数m，即a[0]=m.则数组的每个元素存储k的阶乘k!的一位数字，并从低位到高位依次存于数组的第二个元素，第三个元素…例如，5!=120,在数组中的存储形式为：首元素表示长整数是一个3位数，接着是低位到高位依次是0、2、1，表示长整数是120.计算阶乘k!可采用对已求的阶乘(k-1)!连续再累加k-1次后求出.例如，已知4！=24，计算5！，可对原来的24再累加4个24后得到120.。

算法设计习题(完整)

本文算法设计题涉及的顺序表和线性链表的类型定义如下：#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{Elem Type *elem;int length;int listsize;}SqList;typedef struct LNode{ELem Type data;Struct LNode *next;}LNode,*LinkList;算法设计习题1、设顺序表va中的数据元素递增有序。

试写一算法，将x插入到顺序表的适当位置上，以保持该表的有序性。

void Insert(Sqlist &L,int e) //把e插入到递增顺序表L中{int i;int *newbase;if(L.length>=L.listsize) //va空间不足{newbase=(int *)malloc((LISTINCREMENT+L.listsize)*sizeof(int)); //分配空间if(!newbase) exit(OVERFLOW); //分配空间不成功则返回L.elem=newbase; //新基址L.listsize=L.listsize+LISTINCREMENT; //增加存储容量}for(i=L.length-1; (i>=0)&&(L.elem[i]>e); i--)L.elem[i+1]=L.elem[i]; //大于e的元素依次后移L.elem[i+1]=e; //插入eL.length++; //长度+1}2、设A=(a1,…..a m)和B=(b1,……,b n)均为顺序表，A’和B’分别为A和B中除去最大共同前缀后的子表(例如，A=(x,y,y,z,x,z),B=(x,y,y,z,y,x,x,z),则两者中最大的共同前缀为(x,y,y,z)，在两表中除去最大共同前缀后的子表分别为A’=(x,z)和B’=(y,x,x,z)。