下载文档原格式
A.1-1求的简化公式。
利用等差级数求和公式和级数线性性质：
A.1-2利用调和级数性质证明。
利用调和级数性质：
A.1-3对，证明。
对无穷递减几何级数式两边求导，再乘以：
对该式再进行同上操作得到：
A.1-4 求。
A.1-5 求的值。
当时求得
当时：
计算得到：
A.1-6 利用求和公式的线性特征证明。
令，则下式显然成立：
再把函数代换回即可。
A.1-7 求的值。
A.1-8 求的值。
A.2-1 证明有常量上界。
A.2-2 求和的渐近上界。
故渐近上界是
A.2-3 通过分割求和证明第个调和数是。
故取得下界
A.2-4 通过积分求的近似值。
A.2-5 题略。
为了保证被积函数在积分域上都连续。
思考题
A-1 求和的界
求下列和式的渐近确界。
假设，都是常量。
a)
，得到确界为
b)
根据此式得到上界：
故得到下界：
故据此得到确界
c)
故得到上界：
故得到下界：
因此得到确界。
算法导论第九章习题答案（第三版）IntroductiontoAlgorithm Exercise
9.1-1
对所有的元素，两个⼀组进⾏⽐较，共需n-1次⽐较，可以构成⼀棵⼆叉树，最⼩的元素在树的根结点上，接下来，画出⼆叉树，可以很容易的看出共需lgn-1次⽐较，所以共需n+lgn-2次⽐较才可以找出第⼆⼩的元素。
9.1-2
略。
9.2-1
在randomized-select中，对于长度为0的数组，此时p=r，直接返回A[p],所以不会进⾏递归调⽤。
9.2-2
略。
9.2-3
RANDOMIZED-SELECT(A,p,r,i){
while(true){
if(p==r)
return A[p];
q=RANDOMIZED-PARTITION(A,p,r);
k=q-p+1;
if(i==k)
return A[q];
else if(i<k)
q--;
else{
q++;
i-=k;
}
}
}
9.2-4
每次都以最⼤的元素进⾏划分即可。
9.3-1
数学计算，根据书中例题仿照分析即可。
9.3-3
随机化
9.3-5
类似主元划分，只要把⿊箱⼦输出的值作为主元划分去选择即可。
9.3-6
多重⼆分即可。
9.3-7
算出中位数，之后算出每⼀个数与中位数的差即可。
9.3-8
分别取两个数组的中位数进⾏⽐较，如果两个中位数相等，那么即为所求，否则，取中位数较⼩的⼀个的右边，取较⼤的⼀个的右边，直到就剩4个元素为⽌，这时候只要求这4个元素的中位数即可。
算法导论参考答案算法导论参考答案算法导论是计算机科学领域中一本经典的教材，被广泛应用于计算机科学和工程的教学和研究中。
它涵盖了算法设计和分析的基本概念，以及各种常见算法的实现和应用。
本文将为读者提供一些算法导论中常见问题的参考答案，以帮助读者更好地理解和掌握这门课程。
1. 什么是算法？算法是一系列解决问题的步骤和规则。
它描述了如何将输入转换为输出，并在有限的时间内完成。
算法应具备正确性、可读性、健壮性和高效性等特点。
2. 如何分析算法的效率？算法的效率可以通过时间复杂度和空间复杂度来衡量。
时间复杂度表示算法执行所需的时间量级，常用的时间复杂度有O(1)、O(n)、O(logn)、O(nlogn)和O(n^2)等。
空间复杂度表示算法执行所需的额外空间量级，通常以字节为单位。
3. 什么是渐进符号？渐进符号用于表示算法的时间复杂度或空间复杂度的增长趋势。
常见的渐进符号有大O符号、Ω符号和Θ符号。
大O符号表示算法的上界，Ω符号表示算法的下界，Θ符号表示算法的平均情况。
4. 什么是分治法？分治法是一种算法设计策略，将问题分解为若干个子问题，并对子问题进行独立求解，最后将子问题的解合并得到原问题的解。
典型的分治算法有归并排序和快速排序。
5. 什么是动态规划？动态规划是一种通过将问题分解为相互重叠的子问题来求解的方法。
它通常用于求解具有重叠子问题和最优子结构性质的问题。
典型的动态规划算法有背包问题和最短路径问题。
6. 什么是贪心算法？贪心算法是一种通过每一步选择局部最优解来求解整体最优解的方法。
贪心算法通常不能保证得到全局最优解，但在某些问题上能够得到近似最优解。
典型的贪心算法有霍夫曼编码和最小生成树算法。
7. 什么是图算法？图算法是一类用于解决图结构相关问题的算法。
图由节点和边组成，节点表示对象，边表示对象之间的关系。
图算法包括图的遍历、最短路径、最小生成树和网络流等问题的求解。
8. 什么是NP完全问题？NP完全问题是一类在多项式时间内无法求解的问题。
算法导论32章答案32 String Matching32.1-2Suppose that all characters in the pattern P are different. Show how to accelerate NAIVE-STRING-MATCHER to run in timeO.n/ on an n-character text T.Naive-Search(T,P)for s = 1 to n – m + 1j = 0while T[s+j] == P[j] doj = j + 1if j = m return ss = j + s;该算法实际只是会扫描整个字符串的每个字符⼀次，所以其时间复杂度为O(n).31.1-3Suppose that pattern P and text T are randomly chosen strings of length m and n, respectively, from the d-ary alphabet ∑d ={0,1,2,..,d-1},where d ≧ 2.Show that the expected number of character-to-character comparisons made by the implicit loop inline 4 of the naive algorithm isover all executions of this loop. (Assume that the naive algorithm stops comparing characters for a given shift once it finds amismatch or matches the entire pattern.) Thus, for randomly chosen strings, the naive algorithm is quite efficient.当第4⾏隐含的循环执⾏i次时，其概率P为：P = 1/K i-1 * (1-1/k), if i < mP = 1/K m-1 * (1-1/k) + 1/K m , if i = m可以计算每次for循环迭代时，第4⾏的循环的平均迭代次数为：[1*(1-1/k)+2*(1/K)*(1-1/k)+3*(1/k2)(1-1/k)+…+(m-1)*(1-k m-2)(1-1/k) +m*(1/k m-1)(1-1/k) + m*(1/k m)]= 1 - 1/k + 2/k - 2/k2 + 3/k2 - 3/k3 +...+ m/k m-1 - m/k m + m/k m= 1 + 1/k + 1/k2 +...+ 1/k m-1= (1 - 1/K m) / (1 - 1/k)≤ 2所以，可知，第4⾏循环的总迭代次数为：(n-m+1) * [(1-1/K m) / (1-1/k)] ≤ 2 (n-m+1)31.1-4Suppose we allow the pattern P to contain occurrences of a gap character } that can match an arbitrary string of characters(even one of zero length). For example, the pattern ab}ba}c occurs in the text cabccbacbacab asand asNote that the gap character may occur an arbitrary number of times in the pattern but not at all in the text. Give a polynomial-time algorithm to determine whether such a pattern P occurs in a given text T, and analyze the running time of your algorithm.该算法只是要求判断是否模式P出现在该字符串中，那么问题被简化了许多。
第二章算法入门由于时间问题有些问题没有写的很仔细，而且估计这里会存在不少不恰当之处。
另，思考题2-3 关于霍纳规则，有些部分没有完成，故没把解答写上去，我对其 c 问题有疑问，请有解答方法者提供个意见。
给出的代码目前也仅仅为解决问题，没有做优化，请见谅，等有时间了我再好好修改。
插入排序算法伪代码INSERTION-SORT(A)1 for j ←2 to length[A]2 do key ←A[j]3 Insert A[j] into the sorted sequence A[1..j-1]4 i ←j-15 while i > 0 and A[i] > key6 do A[i+1]←A[i]7 i ←i − 18 A[i+1]←keyC#对揑入排序算法的实现:public static void InsertionSort<T>(T[] Input) where T:IComparable<T>{T key;int i;for (int j = 1; j < Input.Length; j++){key = Input[j];i = j - 1;for (; i >= 0 && Input[i].CompareTo(key)>0;i-- )Input[i + 1] = Input[i];Input[i+1]=key;}}揑入算法的设计使用的是增量（incremental）方法：在排好子数组A[1..j-1]后，将元素A[ j]揑入，形成排好序的子数组A[1..j]这里需要注意的是由于大部分编程语言的数组都是从0开始算起，这个不伪代码认为的数组的数是第1个有所丌同，一般要注意有几个关键值要比伪代码的小1.如果按照大部分计算机编程语言的思路，修改为：INSERTION-SORT(A)1 for j ← 1 to length[A]2 do key ←A[j]3 i ←j-14 while i ≥ 0 and A[i] > key5 do A[i+1]←A[i]6 i ←i − 17 A[i+1]←key循环丌变式(Loop Invariant)是证明算法正确性的一个重要工具。
算法导论9.1-1习题解答（⼆叉树）CLRS 9.1-1 :证明：在最坏情况下，利⽤n + [lgn] - 2此⽐较，即可找到n个元素中的第2⼩元素。
（提⽰：同时找最⼩元素)算法思想：1.将数组中的元素分组，每组两个元素，然后⽐较每组中的两个元素得到最⼩值，重新得到包含原来⼀半元素的数组，继续重复上述过程，那么最后⼀个元素必然为最⼩值。
如图所⽰，数组为{2, 1, 4, 3, 5}2.上述过程形成的是⼀个⼆叉树，其中叶⼦节点都为数组元素，⾮叶⼦节点刚好4个，这是⼆叉树的性质。
3.然后我们来找第⼆⼩元素，第⼆⼩元素必然跟着1，⾸先赋值为5，然后再赋值为3，然后赋值为2，即为所求。
PS：本章讨论的元素都互异，不存在相同值(见原书)#include <iostream>using namespace std;class Node{public:Node* left;Node* right;int data;Node();Node(int d);};class BinaryTree{public:Node* root;//创建树void create_tree(Node** node, int len);//求最⼩值int min(int a, int b);//寻找第⼆⼩值int search_second_small();BinaryTree();};int main(){int arr[10] = {89, 123, 7, 9, 2, 5, 25, 8, 43, 23};//叶⼦节点Node** node =new Node*[10];for(int i =0; i <10; i++)node[i] =new Node(arr[i]);BinaryTree* bi_tree =new BinaryTree();bi_tree->create_tree(node, 10);cout<<bi_tree->root->data<<endl;cout<<bi_tree->search_second_small()<<endl;return 0;}Node::Node(){left = right = NULL;}Node::Node(int d){data = d;left = right = NULL;}void BinaryTree::create_tree(Node** node, int len){//len == 2时，就剩下两个元素进⾏⽐较了，得到最后⼀个元素为root节点，即最⼩值节点 if(len ==2){root->left = node[0];root->right = node[1];root->data = min(node[0]->data, node[1]->data);}else{int new_len = (len%2) ? (len/2+1) : len/2;Node** new_node =new Node*[new_len];//new_node元素个数为奇数if(len%2){for(int i =0; i < new_len -1; i++){//构建⽗亲节点new_node[i] =new Node(min(node[2*i]->data, node[2*i+1]->data));new_node[i]->left = node[2*i];new_node[i]->right = node[2*i+1];}new_node[new_len -1] = node[len -1];}//new_node元素个数为偶数else{for(int i =0; i < new_len; i++){//构建⽗亲节点new_node[i] =new Node(min(node[2*i]->data, node[2*i+1]->data));new_node[i]->left = node[2*i];new_node[i]->right = node[2*i+1];}}create_tree(new_node, new_len);delete[] new_node;}}int BinaryTree::min(int a, int b){return a < b ? a : b;}int BinaryTree::search_second_small(){int second =1000000;Node* p = root;while(p->left != NULL && p->right != NULL){if(p->data == p->left->data && second > p->right->data){second = p->right->data;p = p->left;}else if(p->data == p->right->data && second > p->left->data){second = p->left->data;p = p->right;}elsereturn second;}return second;}BinaryTree::BinaryTree() {root = new Node();}。
