第六章 递归与分治法
算法设计与分析(王晓东)
a b a b
（2）方法重载：Java允许方法重载，即允许定义有不同签名的同名方法。
上述方法ab可重载为：
public static double ab(double a, double b) { return (a+b+Math.abs(a-b))/2.0; } 12
4.异常
1.3 描述算法
6
1.2 表达算法的抽象机制
2.抽象数据类型
抽象数据类型是算法的一个数据模型连同定义在该模型上 并作为算法构件的一组运算。
抽象数据类型带给算法设计的好处有：
（1）算法顶层设计与底层实现分离； （2）算法设计与数据结构设计隔开，允许数据结构自由选择； （3）数据模型和该模型上的运算统一在ADT中，便于空间和时间耗费的折衷； （4）用抽象数据类型表述的算法具有很好的可维护性； （5）算法自然呈现模块化； （6）为自顶向下逐步求精和模块化提供有效途径和工具； （7）算法结构清晰，层次分明，便于算法正确性的证明和复杂性的分析。
中国计算机学会 “21世纪大学本科计算机专业系列教材”
算法设计与分析
王晓东 编著
1
主要内容介绍
• • • • • • 第1章 第2章 第3章 第4章 第5章 第6章 算法引论 递归与分治策略 动态规划 贪心算法 回溯法 分支限界法
递归与分治算法心得
递归与分治算法心得
递归与分治算法都是常用的算法思想，可以很好地解决复杂问题。
递归算法是通过将问题分解为相同或相似的子问题来解决整个问题，然后再逐步合并回原问题的过程。
递归算法通常需要明确边界条件，以确保递归能够正确地停止。
分治算法是将问题分解成若干个相同或相似的子问题，递归地解决这些子问题，然后合并这些子问题的解来解决原始问题。
通常，分治算法可以高效地解决问题，但需要注意分解问题的方式和合并子问题的解的过程。
在实际应用中，递归和分治算法可以相互结合，以解决更加复杂的问题。
例如，可以使用分治算法来将问题分解成多个子问题，然后使用递归算法来解决这些子问题。
此外，还可以在递归算法中使用分治算法来对子问题进行分解和合并。
总而言之，递归与分治算法都是非常有用的算法思想，可以在许多领域中得到应用。
但是，在实际使用时，需要仔细考虑问题的性质和算法的复杂度，以确保算法的正确性和效率。
- 1 -。
递归与分治算法心得
递归与分治算法心得
递归与分治算法是算法设计中常见的两种方法，它们在解决问题时都采用了“分而治之”的思想，将问题分解成更小的子问题，然后通过递归调用或者合并子问题的解来得到原问题的解。
通过我的学习和实践，我深刻认识到了递归与分治算法的重要性和优势。
首先，递归算法可以使问题的描述更加简单明了。
通过将问题转化为自身的子问题，我们可以建立起更为简洁优美的数学模型。
其次，递归算法可以使问题的解决过程更加自然。
在递归过程中，我们可以利用已知的子问题解决同类问题，实现代码的复用和模块化。
此外，递归算法还可以解决一些重要的数学问题，如斐波那契数列和二分查找等。
分治算法则更加注重问题的分解和合并。
它将问题划分成若干个规模相同或相近的子问题，然后将子问题的解合并起来得到原问题的解。
这种方法在解决某些复杂问题时具有很大的优势。
例如，在排序算法中，归并排序采用了分治算法的思想，将待排序的序列分成两个长度相等的子序列，然后递归地对子序列排序，最后将子序列合并成有序序列。
这种算法具有较高的稳定性和灵活性，常常被应用于海量数据的排序任务中。
总之，递归与分治算法是算法设计中不可或缺的两种方法。
在解决问题时，我们应该根据具体情况选择合适的算法，并在实践中不断探索、总结和优化。
只有这样，我们才能更好地应对日益复杂多变的计算机科学挑战。
分治法解决问题的步骤
分治法解决问题的步骤一、基础概念类题目（1 - 5题）题目1：简述分治法解决问题的基本步骤。
解析：分治法解决问题主要有三个步骤：1. 分解（Divide）：将原问题分解为若干个规模较小、相互独立且与原问题形式相同的子问题。
例如，对于排序问题，可将一个大的数组分成两个较小的子数组。
2. 求解（Conquer）：递归地求解这些子问题。
如果子问题规模足够小，则直接求解（通常是一些简单的基础情况）。
对于小到只有一个元素的子数组，它本身就是有序的。
3. 合并（Combine）：将各个子问题的解合并为原问题的解。
在排序中，将两个已排序的子数组合并成一个大的有序数组。
题目2：在分治法中，分解原问题时需要遵循哪些原则？解析：1. 子问题规模更小：分解后的子问题规模要比原问题小，这样才能逐步简化问题。
例如在归并排序中，不断将数组对半分，子数组的长度不断减小。
2. 子问题相互独立：子问题之间应该尽量没有相互依赖关系。
以矩阵乘法的分治算法为例，划分后的子矩阵乘法之间相互独立进行计算。
3. 子问题与原问题形式相同：方便递归求解。
如二分查找中，每次查找的子区间仍然是一个有序区间，和原始的有序区间查找问题形式相同。
题目3：分治法中的“求解”步骤，如果子问题规模小到什么程度可以直接求解？解析：当子问题规模小到可以用简单的、直接的方法（如常量时间或线性时间复杂度的方法）解决时，就可以直接求解。
例如，在求数组中的最大最小值问题中，当子数组只有一个元素时，这个元素既是最大值也是最小值，可以直接得出结果。
题目4：分治法的“合并”步骤有什么重要性？解析：1. 构建完整解：它将各个子问题的解组合起来形成原问题的解。
例如在归并排序中，单独的两个子数组排序好后，只有通过合并操作才能得到整个数组的有序排列。
2. 保证算法正确性：如果合并步骤不正确，即使子问题求解正确，也无法得到原问题的正确答案。
例如在分治算法计算斐波那契数列时，合并不同子问题的结果来得到正确的斐波那契数是很关键的。
递归和分治法
递归和分治法摘要：1.递归和分治法的定义2.递归和分治法的区别3.递归和分治法的应用实例4.递归和分治法的优缺点正文：递归和分治法是计算机科学中常用的两种算法设计技巧。
它们在解决问题时都采用了将问题分解成更小子问题的思路，但在具体实现上却有所不同。
下面，我们来详细了解一下递归和分治法。
1.递归和分治法的定义递归法是指在算法中调用自身来解决问题的方法。
递归函数在执行过程中，会将原问题分解成规模更小的相似子问题，然后通过调用自身的方式，解决这些子问题，最后将子问题的解合并，得到原问题的解。
分治法是指将一个大问题分解成若干个规模较小的相似子问题，然后分别解决这些子问题，最后将子问题的解合并，得到原问题的解。
分治法在解决问题时，通常需要设计一个主函数（master function）和一个子函数（subfunction）。
主函数负责将问题分解，子函数负责解决子问题。
2.递归和分治法的区别递归法和分治法在解决问题时都采用了将问题分解成更小子问题的思路，但它们在实现上存在以下区别：（1）函数调用方式不同：递归法是通过调用自身来解决问题，而分治法是通过调用不同的子函数来解决问题。
（2）递归法必须有递归出口，即必须有一个基线条件，而分治法不一定需要。
3.递归和分治法的应用实例递归法应用广泛，例如斐波那契数列、汉诺塔问题、八皇后问题等。
分治法也有很多实际应用，例如快速排序、归并排序、大整数乘法等。
4.递归和分治法的优缺点递归法的优点是代码简单易懂，但缺点是容易产生大量的重复计算，导致时间复杂度较高。
分治法的优点是时间复杂度较低，但缺点是代码实现相对复杂，需要设计主函数和子函数。
总之，递归和分治法都是解决问题的有效方法，具体应用需要根据问题的特点来选择。
计算机算法的数学原理
计算机算法的数学原理计算机算法的数学原理计算机算法是计算机科学中的核心概念之一。
算法是一种规定好的计算步骤，用来解决特定问题的方法。
算法的正确性、高效性和可扩展性非常重要，这些关键因素都与数学原理紧密相连。
因此，本文将讨论计算机算法的数学原理，重点探讨算法设计、分析和应用方面的数学，希望能对读者有所启示。
第一部分：算法设计算法设计是计算机算法中的重要部分，它需要设计者具有数学思维和计算思维。
在设计算法时，需要考虑输入、输出、执行步骤和运行时间等方面。
其中，输入是指算法能够处理的数据类型和数据格式，输出是指算法输出的结果类型和格式，执行步骤是指算法执行的操作和顺序，运行时间是指算法完成执行所需的时间。
在算法设计中，有一些基础的数学原理非常重要，包括递归、迭代和分治等。
这些数学概念可以用来描述算法的递推式和复杂度，并可以为算法的优化提供指导。
1.递归递归是指在函数或子过程中调用自身。
递归常常可以简化算法的实现和代码的可读性。
递归的本质是将规模大的问题分解为规模较小的子问题，并通过递推求解出最终解。
递归需要考虑递归终止条件和递归式两个方面。
例如，计算斐波那契数列的第n项可以使用递归算法，其递推式为：f(n) = f(n-1) + f(n-2) (n >= 3) f(1) = 1, f(2) = 1通过递归式和递归终止条件可以求解斐波那契数列的任意项，例如：int fib(int n) { if (n == 1 || n == 2) return 1; return fib(n-1) + fib(n-2); }上述代码实现了斐波那契数列的递归算法，计算时间复杂度为O(2^n)，因为对于每一项都需要递归计算。
为了提高效率，可以使用动态规划等方法。
2.迭代迭代是指在一定条件下重复执行同一操作，直到满足结束条件。
迭代的本质是通过循环求解出问题的最终解。
迭代需要考虑循环终止条件和迭代式两个方面。
例如，计算斐波那契数列的第n项可以使用迭代算法，其迭代式为：f[1] = f[2] = 1; for (int i = 3; i <= n; i++) { f[i] = f[i-1] + f[i-2]; }通过迭代式和循环终止条件可以求解斐波那契数列的任意项，例如：int fib(int n) { if (n == 1 || n == 2) return 1; int f[3] = {1, 1, 0}; for (int i = 3; i <= n; i++) { f[2] = f[0] + f[1]; f[0] = f[1]; f[1] = f[2]; } return f[2]; }上述代码实现了斐波那契数列的迭代算法，计算时间复杂度为O(n)，因为只需要遍历一遍数组即可求解。
算法设计与分析复习题整理 (1)
一、基本题：算法：1、程序是算法用某种程序设计语言的具体实现。
2、算法就是一组有穷的序列(规则) ，它们规定了解决某一特定类型问题的一系列运算。
3、算法的复杂性是算法效率的度量，是评价算法优劣的重要依据。
4、算法的“确定性”指的是组成算法的每条指令是清晰的，无歧义的。
5、算法满足的性质：输入、输出、确定性、有限性。
6、衡量一个算法好坏的标准是时间复杂度低。
7、算法运行所需要的计算机资源的量，称为算法复杂性，主要包括时间复杂性和空间复杂性。
8、任何可用计算机求解的问题所需的时间都与其规模有关。
递归与分治：9、递归与分治算法应满足条件：最优子结构性质与子问题独立。
10、分治法的基本思想是首先将待求解问题分解成若干子问题。
11、边界条件与递归方程是递归函数的两个要素。
12、从分治法的一般设计模式可以看出，用它设计出的程序一般是递归算法。
13、将一个难以直接解决的大问题，分解成一些规模较小的相同问题，以便各个击破。
这属于分治法的解决方法。
14、Strassen矩阵乘法是利用分治策略实现的算法。
15、大整数乘积算法是用分治法来设计的。
16、二分搜索算法是利用分治策略实现的算法。
动态规划：17、动态规划算法的两个基本要素是最优子结构性质和重叠子问题性质。
18、下列算法中通常以自底向上的方式求解最优解的是动态规划法。
19、备忘录方法是动态规划算法的变形。
20、最优子结构性质是贪心算法与动态规划算法的共同点。
21、解决0/1背包问题可以使用动态规划、回溯法，其中不需要排序的是动态规划，需要排序的是回溯法。
贪心算法：22、贪心算法总是做出在当前看来最好的选择。
也就是说贪心算法并不从整体最优考虑，它所做出的选择只是在某种意义上的局部最优解。
23、最优子结构性质是贪心算法与动态规划算法的共同点。
24、背包问题的贪心算法所需的计算时间为 O(nlogn) 。
回溯法：25、回溯法中的解空间树结构通常有两种，分别是子集树和排列树。
算法设计与分析：递归与分治法-实验报告(总8页)
算法设计与分析：递归与分治法-实验报告(总8页)实验目的：掌握递归与分治法的基本思想和应用，学会设计和实现递归算法和分治算法，能够分析和评价算法的时间复杂度和空间复杂度。
实验内容：1.递归算法的设计与实现3.算法的时间复杂度和空间复杂度分析实验步骤：1）递归定义：一个函数或过程，在其定义或实现中，直接或间接地调用自身的方法，被成为递归。
递归算法是一种控制结构，它包含了解决问题的基础情境，也包含了递归处理的情境。
2）递归特点：递归算法具有以下特点：①依赖于递归问题的部分解被划分为若干较小的部分。
②问题的规模可以通过递推式递减，最终递归终止。
③当问题的规模足够小时，可以直接求解。
3）递归实现步骤：①确定函数的定义②确定递归终止条件③确定递归调用的过程4）经典实例：斐波那契数列递推式：f(n) = f(n-1) + f(n-2)int fib(int n) {if (n <= 0)return 0;else}5）优化递归算法：避免重复计算例如，上述斐波那契数列的递归算法会重复计算一些中间结果，影响效率。
可以使用动态规划技术，将算法改为非递归形式。
int f1 = 0, f2 = 1;for (int i = 2; i <= n; i++) {f1 = f2;使用循环避免递归，重复计算可以大大减少，提高效率。
1）分治算法的定义：将原问题分解成若干个规模较小且类似的子问题，递归求解子问题，然后合并各子问题得到原问题的解。
2）分治算法流程：②将问题分解成若干个规模较小的子问题。
③递归地解决各子问题。
④将各子问题的解合并成原问题的解。
3）分治算法实例：归并排序归并排序是一种基于分治思想的经典排序算法。
排序流程：②分别对各子数组递归进行归并排序。
③将已经排序好的各子数组合并成最终的排序结果。
实现源代码：void mergeSort(int* arr, int left, int right) {if (left >= right)while (i <= mid && j <= right)temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];temp[k++] = arr[i++];1) 时间复杂度的概念：指完成算法所需的计算次数或操作次数。
教你如何简单解决递归问题
教你如何简单解决递归问题递归问题是计算机科学中常见的一个概念，它在编程中经常被用到。
虽然递归算法能够帮助我们解决一些复杂的问题，但是在实际应用中，递归问题可能会导致效率低下、内存溢出等不良后果。
针对这些问题，本文将介绍一些简单有效的方法，帮助你解决递归问题，以提高程序的性能和效率。
1. 迭代代替递归递归算法的本质是函数不断调用自身，但是函数调用会产生额外的开销，尤其是在处理大规模的数据时。
为了简化递归问题，我们可以考虑使用迭代代替递归。
迭代算法使用循环结构来代替函数调用，从而减少开销，提高效率。
2. 减少递归深度递归算法的一个问题是递归深度过深，可能导致栈溢出。
为了解决这个问题，我们可以通过减少递归深度来降低风险。
一种常见的方法是使用尾递归优化。
尾递归是指在递归函数的最后一步调用自身，这样编译器可以将递归转化为迭代，从而减少递归深度。
3. 缓存中间结果递归算法的另一个问题是重复计算相同的子问题，这样会浪费时间和计算资源。
为了解决这个问题，我们可以使用缓存来存储中间结果。
缓存可以避免重复计算，提高计算效率。
一种常见的缓存方法是使用哈希表来记录已经计算过的结果，这样可以在下次遇到相同的子问题时直接查表而不需要重新计算。
4. 分治法分治法是一种常用的解决递归问题的方法。
其基本思想是将问题划分为多个子问题，然后分别解决这些子问题，并将结果合并得到最终的解。
分治法可以通过递归的方式来实现，但是由于分而治之的特点，它可以显著降低递归的复杂度。
5. 动态规划动态规划是一种高效解决递归问题的方法。
它基于问题的最优子结构特性，通过将问题分解为相互重叠的子问题，并使用递推的方式求解。
与递归算法相比，动态规划算法可以避免重复计算，提高效率。
总结：递归问题在计算机科学中广泛存在，但是在实际应用中，我们经常需要解决递归问题导致的效率低下、内存溢出等问题。
通过使用迭代代替递归、减少递归深度、缓存中间结果、分治法和动态规划等方法，我们可以简单解决递归问题，提高程序的性能和效率。
对于一个规模为n的问题
分治法简介对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。
这种算法设计策略叫做分治法。
分治法的基本思想任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。
问题的规模越小，越容易直接求解，解题所需的计算时间也越少。
例如，对于n个元素的排序问题，当n=1时，不需任何计算。
n=2时，只要作一次比较即可排好序。
n=3时只要作3次比较即可，…。
而当n较大时，问题就不那么容易处理了。
要想直接解决一个规模较大的问题，有时是相当困难的。
分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。
如果原问题可分割成k个子问题，1<k≤n ，且这些子问题都可解，并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。
由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。
在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。
这自然导致递归过程的产生。
分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。
分治法的适用条件分治法所能解决的问题一般具有以下几个特征：1.该问题的规模缩小到一定的程度就可以容易地解决；2.该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3.利用该问题分解出的子问题的解可以合并为该问题的解；4.该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
上述的第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；第二条特征是应用分治法的前提，它也是大多数问题可以满足的，此特征反映了递归思想的应用；第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑贪心法或动态规划法。
递归算法2
见程序事例
1 1 1 1 1 1
2 2 3 3 4 4
3 4 2 4 2 3
4 3 4 2 3 2
1 2 3 4 1 ↔ 2 2 1 3 4
2 2 2 2 2 2
1 1 3 3 4 4
3 4 1 4 1 3
4 3 4 1 3 1
2 1 3 4 1 ↔ 2 1 2 3 4
1 2 3 4 1 ↔ 3 3 2 1 4
例4 Hanoi塔问题 设a,b,c是3个塔座。开始时，在塔座a上有一叠共n个圆 盘，这些圆盘自下而上，由大到小地叠在一起。各圆 盘从小到大编号为1,2,…,n,现要求将塔座a上的这一 叠圆盘移到塔座b上，并仍按同样顺序叠置。在移动圆 盘时应遵守以下移动规则： 规则1：每次只能移动1个圆盘； 规则2：任何时刻都不允许将较大的圆盘压在较小的圆盘 之上； 规则3：在满足移动规则1和2的前提下，可将圆盘移至 a,b,c中任一塔座上。
ACM竞赛辅导-2 分治与递归
北方民族大学 计算机科学与工程学院 王伦津
分治法的设计思想是，将一个难以直接解决 各个 击破， 分而治之。 凡治众如治寡，分数是也。
----孙子兵法
将求出的小规模的问题的解合并 为一个更大规模的问题的解，自 底向上逐步求出原来问题的解。
2.1 递归的概念
例1 阶乘函数 阶乘函数可递归地定义为： 边界条件
n0 1 n! n(n 1)! n 0
递归方程
边界条件与递归方程是递归函数的二个要素，递归函 数只有具备了这两个要素，才能在有限次计算后得出 结果。 Int Factorial(int n) { if(n==0) return 1; return n* Factorial(n-1); }
合并排序
算法设计与分析知识点
第一章算法概述1、算法的五个性质：有穷性、确定性、能行性、输入、输出。
2、算法的复杂性取决于：(1)求解问题的规模(N) , (2)具体的输入数据(I),( 3)算法本身的设计(A)，C=F(N,I,A。
3、算法的时间复杂度的上界，下界，同阶，低阶的表示。
4、常用算法的设计技术：分治法、动态规划法、贪心法、回溯法和分支界限法。
5、常用的几种数据结构：线性表、树、图。
第二章递归与分治1、递归算法的思想：将对较大规模的对象的操作归结为对较小规模的对象实施同样的操作。
递归的时间复杂性可归结为递归方程：1 11= 1T(n) <aT(n—b) + D(n) n> 1其中，a是子问题的个数，b是递减的步长，~表示递减方式，D(n)是合成子问题的开销。
递归元的递减方式~有两种：1、减法，即n -b，的形式。
2、除法，即n / b，的形式。
2、D(n)为常数c：这时，T(n) = 0(n P)。
D(n)为线形函数cn：r O(n) 当a. < b(NT(n) = < Ofnlog^n) "n = blljI O(I1P)二"A bl吋其中.p = log b a oD(n)为幕函数n x：r O(n x) 当a< D(b)II JT{ii) = O(ni1og b n) 'ia = D(b)ll].O(nr)D(b)lHJI：中，p= log b ao考虑下列递归方程：T(1) = 1⑴ T( n) = 4T(n/2) +n⑵ T(n) = 4T(n/2)+n2⑶ T(n) = 4T(n/2)+n3解：方程中均为a = 4，b = 2，其齐次解为n2。
对⑴，T a > b (D(n) = n) /• T(n) = 0(n);对⑵，•/ a = b2 (D(n) = n2) T(n) = O(n2iog n);对⑶，•/ a < b3(D(n) = n3) - T(n) = 0(n3)；证明一个算法的正确性需要证明两点：1、算法的部分正确性。
递推-递归-分治-回溯
递推算法在程序编辑过程中，我们可能会遇到这样一类问题，出题者告诉你数列的前几个数，或通过计算机获取了数列的前几个数，要求编程者求出第N项数或所有的数列元素（如果可以枚举的话），或求前N项元素之和。
这种从已知数据入手，寻找规则，推导出后面的数的算法，称这递推算法。
典型的递推算法的例子有整数的阶乘，1，2，6，24，120…，a[n]=a[n-1]*n(a[1]=1)；前面学过的2n，a[n]=a[n-1]*2(a[1]=1)，菲波拉契数列：1，2，3，5，8，13…，a[n]=a[n-1]+a[n-2](a[1]=1,a[2]=2)等等。
在处理递推问题时，我们有时遇到的递推关系是十分明显的，简单地写出递推关系式，就可以逐项递推，即由第i项推出第i+1项，我们称其为显示递推关系。
但有的递推关系，要经过仔细观察，甚至要借助一些技巧，才能看出它们之间的关系，我们称其为隐式的递推关系。
下面我们来分析一些例题，掌握一些简单的递推关系。
例如阶梯问题：题目的意思是：有N级阶梯，人可以一步走上一级，也可以一步走两级，求人从阶梯底走到顶端可以有多少种不同的走法。
这是一个隐式的递推关系，如果编程者不能找出这个递推关系，可能就无法做出这题来。
我们来分析一下：走上第一级的方法只有一种，走上第二级的方法却有两种（两次走一级或一次走两级），走上第三级的走法，应该是走上第一级的方法和走上第二级的走法之和（因从第一级和第二级，都可以经一步走至第三级），推广到走上第i级，是走上第i-1级的走法与走上第i-2级的走法之和。
很明显，这是一个菲波拉契数列。
到这里，读者应能很熟练地写出这个程序。
在以后的程序习题中，我们可能还会遇到菲波拉契数列变形以后的结果：如f(i)=f(i-1)+2f(i-2)，或f(i)=f(i-1)+f(i-2)+f(i-3)等。
我们再来分析一下尼科梅彻斯定理。
定理内容是：任何一个整数的立方都可以写成一串连续的奇数和，如：43=13+15+17+19=64。
递归和分治法
递归和分治法摘要：一、递归与分治法的概念1.递归：函数调用自身的思想2.分治法：把一个大问题分解成若干个小问题二、递归与分治法的联系与区别1.递归通常作为分治法的实现方式2.分治法不一定要用递归实现三、递归与分治法的应用实例1.快速排序算法2.归并排序算法3.汉诺塔问题正文：递归和分治法是两种在计算机科学中经常使用的解决问题的方法。
递归是一种函数调用自身的思想，即函数在执行过程中，会调用自身来完成某些操作。
而分治法则是把一个大问题分解成若干个小问题，然后逐个解决这些小问题，最后再把它们的解合并，得到大问题的解。
这两种方法在某些情况下可以相互转化，递归通常作为分治法的实现方式，但分治法不一定要用递归实现。
递归与分治法之间的联系在于，递归通常是分治法的实现方式。
在分治法中，我们会把一个大问题分解成若干个小问题，然后通过递归的方式，逐个解决这些小问题。
最后，再把它们的解合并，得到大问题的解。
在这个过程中，递归函数的调用栈会随着问题规模的减小而减小，最终回到原点，从而完成问题的求解。
然而，分治法并不一定要用递归实现。
在一些情况下，我们可以通过迭代的方式，逐个解决小问题，然后把它们的解合并。
这种方式虽然不是通过递归函数调用自身来实现的，但它仍然符合分治法的思想，即把大问题分解成小问题，逐个解决。
递归和分治法在实际问题中有很多应用。
例如，快速排序算法和归并排序算法都是基于分治法的思想设计的。
在快速排序算法中，我们选择一个基准元素，然后把数组中小于基准的元素放在左边，大于基准的元素放在右边，再对左右两个子数组递归地执行相同的操作，直到数组有序。
而在归并排序算法中，我们同样把数组分成左右两个子数组，然后递归地对它们进行排序，最后再把排序好的子数组合并成一个有序的数组。
另一个例子是汉诺塔问题。
在这个问题中，有三个柱子和一个大小不同的圆盘。
要求把圆盘从第一个柱子移动到第三个柱子，每次只能移动一个圆盘，并且大盘不能放在小盘上。
算法分析——分治法
分治算法小组的汇报内容：一、分治算法的基本概念 (2)二、分治算法的基本思想及策略 (2)三、分治法适用的情况 (3)四、分治法的基本步骤 (3)五、分治法的复杂性分析 (4)六、快速傅里叶变换 (5)七、可使用分治法求解的一些经典问题 (9)八、依据分治法设计程序时的思维过程 (9)九、分治法与其它常见算法的比较 (9)小组的分工情况：彭勇讲前五个部分，天西山讲第六个部分，胡化腾讲最后三个部分，吕璐负责汇报的资料收集，小组分工以及最后的资料整理。
三、分治法适用的情况分治法所能解决的问题一般具有以下几个特征：1) 该问题的规模缩小到一定的程度就可以容易地解决2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。
3) 利用该问题分解出的子问题的解可以合并为该问题的解；4) 该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子子问题。
第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；第二条特征是应用分治法的前提它也是大多数问题可以满足的，此特征反映了递归思想的应用；、第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。
第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。
四、分治法的基本步骤分治法在每一层递归上都有三个步骤：step1 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；step2 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题step3 合并：将各个子问题的解合并为原问题的解。
它的一般的算法设计模式如下：Divide-and-Conquer(P)1. if |P|≤n02. then return(ADHOC(P))3. 将P分解为较小的子问题 P1 ,P2 ,...,Pk4. for i←1 to k5. do yi ← Divide-and-Conquer(Pi) △递归解决Pi6. T ← MERGE(y1,y2,...,yk) △合并子问题7. return(T)其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。
计算机仿真常用算法
懂且易于分析，如阶乘函数，Fibonacci数列、整数划分问、九连环问题、
Hanoi塔问题等等。
递归与分治
动态规划
贪心算法
回溯法 分支限界法 蒙特卡罗算法
分治基本思想 分治法的基本思想是将一个规模为n的问题分解为k个规模比较小的子 问题，这些子问题互相独立且与原问题相同。将各子问题的解合并得到原问 题的解。设计模式如下： 从分治法的思想可以看出，用它设计的程序一般是递归算法，因此分
对于一个一致性的p的正确的蒙特卡罗算法，要提高获得正确率的概率，只要执行该算 法若干次，并选择出出现频次最高的解即可。
递归与分治
动态规划
贪心算法
回溯法
分支限界法
蒙特卡罗算法
有一个数组T[n],若其中有一元素T[i] = x ,当x的个数大于n/2,则
称x为数组T的主元素。
bool majority(int *T, int n){ int i = rand(time()) + 1; //随机选取x int x = T[i]; int k = 0; for(int j = 1; j <= n; j++) if(t[ j] == x) k++；
常见分支限界法
基本思想 搜索策略 队列式 优先队列式
每个活节点只有一 次机会成为扩展节点。 一旦成为扩展节点，就 一次性产生所有儿子节 点。判断不可行或不是 最优解的儿子节点并舍 弃，其他节点加入活节 点表，取下一个节点， 重复上述操作....
以广度优先或最 小耗费（最大效 益）优先的方式 搜索解空间数。
治法的计算效率通常可以用递归方程来进行分析。
递归与分治
动态规划
贪心算法
回溯法 分支限界法 蒙特卡罗算法
算法设计与分析实验报告
本科实验报告课程名称：算法设计与分析实验项目：递归与分治算法实验地点：计算机系实验楼110专业班级：物联网1601 学号：2016002105 学生姓名：俞梦真指导教师：郝晓丽2018年05月04 日实验一递归与分治算法1.1 实验目的与要求1．进一步熟悉C/C++语言的集成开发环境；2．通过本实验加深对递归与分治策略的理解和运用。
1.2 实验课时2学时1.3 实验原理分治（Divide-and-Conquer）的思想：一个规模为n的复杂问题的求解，可以划分成若干个规模小于n的子问题，再将子问题的解合并成原问题的解。
需要注意的是，分治法使用递归的思想。
划分后的每一个子问题与原问题的性质相同，可用相同的求解方法。
最后，当子问题规模足够小时，可以直接求解，然后逆求原问题的解。
1.4 实验题目1．上机题目：格雷码构造问题Gray码是一个长度为2n的序列。
序列无相同元素，每个元素都是长度为n的串，相邻元素恰好只有一位不同。
试设计一个算法对任意n构造相应的Gray码（分治、减治、变治皆可）。
对于给定的正整数n，格雷码为满足如下条件的一个编码序列。
（1）序列由2n个编码组成，每个编码都是长度为n的二进制位串。
（2）序列中无相同的编码。
（3）序列中位置相邻的两个编码恰有一位不同。
2．设计思想：根据格雷码的性质，找到他的规律，可发现，1位是0 1。
两位是00 01 11 10。
三位是000 001 011010 110 111 101 100。
n位是前n-1位的2倍个。
N-1个位前面加0，N-2为倒转再前面再加1。
3．代码设计：}}}int main(){int n;while(cin>>n){get_grad(n);for(int i=0;i<My_grad.size();i++)cout<<My_grad[i]<<endl;My_grad.clear();}return 0;}运行结果：1.5 思考题（1）递归的关键问题在哪里？答：1.递归式，就是如何将原问题划分成子问题。
分治法解决集合划分问题分析
由此可见：要想直接解决一个规模 较大的问题，有时是相当困难的。
2、 分治法就是为解决大规模问题而提出的
将要求解的大规模的问题分解为k个较 小规模的问题，对这k个子问题分别求解。
T(n)
T(n/2)
T(n/2)
如果子问题的规模仍然不够小，则再划分 为k个子问题，如此递归的进行下去，直到 问题规模足够小，很容易求出其解为止。
T(n)
T(n/2)
T(n/2)
T(n/4)
T(n/4)
T(n/4)
T(n/4)
分治法的主要思路是，将一个难以直接解 决的大问题，分割成一些规模较小的相同 问题，以便各个击破，分而治之。
T(n)
T(n/2)
T(n/2)
T(n/4)
T(n/4)
T(n/4)
T(n/4)
3、 递归的概念
▪ 直接或间接地调用自身的算法称为递归算 法。用函数自身给出定义的函数称为递归 函数。
▪
cin >> m >> n;
▪
if(m<n)
▪
{
▪
cout << ("error!输入的子集个数多于元素个数，请重新考虑要输入的数据!") << endl;
▪
return 0;
▪
}
▪
else
▪
cout << "total_number " << f(m, n) << endl;
▪ ▪}
return 0;
}
▪ //================== ▪ //集合划分问题 ▪ //================== ▪ # include <iostream>
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
这条特征涉及到分治法的效率，如果各子问题是不独 立的，则分治法要做许多不必要的工作，重复地解公 共的子问题，此时虽然也可用分治法，但一般用动态 规划较好。
分治法的求解过程
一般来说，分治法的求解过程由以下三个阶段组成：
（1）划分：既然是分治，当然需要把规模为n的原问题划分为k个规模较小的 子问题，并尽量使这k个子问题的规模大致相同。
}
思考题：给定a，用二分法设计出求an的算法。
例：计算an，应用分治技术得到如下计算方法：
a
n
n a
a 2 n ´a
34
2
如果 n 1 如果 n 1
32 31 31 3 9
32
分解问题 31 求解每个子问题 3
31
3 9
3
合并子问题的解
81
不是所有的分治法都比简单的蛮力法更有效。
第n个Fibonacci数可递归地计算如下： public static int fibonacci(int n) { if (n <= 1) return 1; return fibonacci(n-1)+fibonacci(n-2); }
边界条件
递归方程
6.1.1 递归算法的特性
三个特性
第六章 递归与分治法
递归
汉诺塔、斐波那契数列、八皇后问题
分治
二分法求方程近似解
6.1
递归
递归是一种在函数和方法中调用自身的编 程技术。 递归（Recursion）就是子程序（或函数） 直接调用自己或通过一系列调用语句间接 调用自己，是一种描述问题和解决问题的 基本方法。 递归有两个基本要素：
穷举法
在可能的解空间逐一尝试（8次比较） 分组（4次比较）
分治法
6.3.1 分治法概述
分治法所能解决的问题一般具有以下几个特征： 该问题的规模缩小到一定的程度就可以容易地解 决； 该问题可以分解为若干个规模较小的同构子问题， 即该问题具有最优子结构性质。 利用该问题分解出的子问题的解可以合并为该问 题的解； 该问题所分解出的各个子问题是相互独立的，即 子问题之间不包含公共的子问题。
1 Q 2 Q 3 Q 4 Q 5 Q 6 Q 7 Q 8 Q 1 2 3 4 5 6 7 8
6.3 分治法
分治法的设计思想是，将一个难以直接解 决的大问题，分割成一些规模较小的相同 问题，以便各个击破，分而治之。
凡治众如治寡，分数是也。
----孙子兵法
6.3.1 问题提出
16枚硬币，一枚伪造硬币，其重量要比真 硬币轻。任务：找出伪造硬币。
求解规模为n的问题可以转化为一个或多个结 构相同、规模较小的问题，然后从这些小问 题的解能方便的构造出大问题的解。 递归调用的次数必须是有限的。 必须有结束递归的条件（边界条件）来终止 递归。即当规模n=1时，能直接得解。
6.1.2 递归的执行过程
递推
把规模为n的问题的求解推到比原问题的规模 较小的问题求解，且必须要有终止递归的情 况。 当获得最简单情况的解后，逐级返回，依次 得到规模较大问题的解。
启发式规则：
1. 平衡子问题：最好使子问题的规模大致相同。也就是将一 个问题划分成大小相等的k个子问题（通常k＝2），这种使子 问题规模大致相等的做法是出自一种平衡（Balancing）子问 题的思想，它几乎总是比子问题规模不等的做法要好。 2. 独立子问题：各子问题之间相互独立，这涉及到分治法的 效率，如果各子问题不是独立的，则分治法需要重复地解公 共的子问题。
6.4 分治法应用
快速排序、归并排序、二分查找 二分法求方程近似解
算法分析
将方程的有解空间平分为两个小区间，然后判断 解在哪个小区间； 继续把有解空间一分为二进行判断，如此周而复 始，直到求出满足精确要求的近似解。
步骤
二分搜索技术
给定已按升序排好序的n个元素a[0:n-1]，现要在这n个元素中找 出一特定元素x。 分析： 该问题的规模缩小到一定的程度就可以容易地解决； 该问题可以分解为若干个规模较小的相同问题; 分解出的子问题的解可以合并为原问题的解； 分解出的各个子问题是相互独立的。 分析：如果n=1即只有一个元素，则只要比较这个元素和x就 分析：比较x和a的中间元素a[mid]，若x=a[mid]，则x在L中的 可以确定x是否在表中。因此这个问题满足分治法的第一个适 位置就是mid；如果x<a[mid]，由于a是递增排序的，因此假 分析：很显然此问题分解出的子问题相互独立，即在a[i]的前 用条件 如x在a中的话，x必然排在a[mid]的前面，所以我们只要在 面或后面查找x是独立的子问题，因此满足分治法的第四个适 a[mid]的前面查找x即可；如果x>a[i]，同理我们只要在a[mid] 用条件。 的后面查找x即可。无论是在前面还是后面查找x，其方法都 和在a中查找x一样，只不过是查找的规模缩小了。这就说明 了此问题满足分治法的第二个和第三个适用条件。
⑴ 边界条件：确定递归到何时终止； ⑵ 递归方程：大问题是如何分解为小问题的。
算法总体思想
对这k个子问题分别求解。如果子问题的规模仍然不 将要求解的较大规模的问题分割成k个更小规模的子 够小，则再划分为k个子问题，如此递归的进行下去， 问题。 直到问题规模足够小，很容易求出其解为止。
T(n)
=
n
回归
递归
优点
结构清晰、可读性强、容易证明算法的正确性
缺点
运行效率低
理论上，所有的递归算法都可以转换成非递归算 法
通过分析，跳过分解部分，直接用循环结构实现求值 过程。 用栈保存程序的运行过程。 利用栈保存参数。
Fibonacci数列非递归：
int Fibo(int n) { if(n==1||n==2)return 1 ; int a1=1,a2=1; int an ; for(int i=3;i<n;i++) { an=a1+a2; a1=a2; a2=an; } return an; }
递归方程 边界条件与递归方程是递归函数的二个要素，递归函 数只有具备了这两个要素，才能在有限次计算后得出 结果。
6.1
递归
例 Fibonacci数列
无穷数列1，1，2，3，5，8，13，21，34，55，…，被 称为Fibonacci数列。它可以递归地定义为：
1 n0 F ( n) 1 n 1 F (n 1) F (n 2) n 1
T(n)
n/2
=
n/2
n
n/2 n/2
T(n/4)T(n/4)T(n/4)T(n/4) T(n/4)T(n/4)T(n/4)T(n/4) T(n/4)T(n/4)T(n/4)T(n/4) T(n/4)T(n/4)T(n/4)T(n/4
6.1
例
递归
边界条件
阶乘函数
阶乘函数可递归地定义为：
n0 1 n! n(n 1)! n 0
T(n/2)
T(n/2)
T(n/2)
T(n/2)
算法总体思想
将求出的小规模的问题的解合并为一个更大规模的问 对这k个子问题分别求解。如果子问题的规模仍然不 题的解，自底向上逐步求出原来问题的解。 够小，则再划分为k个子问题，如此递归的进行下去， 直到问题规模足够小，很容易求出其解为止。
T(n)
n/2
规则1：每次只能移动1个圆盘； 规则2：任何时刻都不允许将较大的圆盘压在较小的圆盘之上； 规则3：在满足移动规则1和2的前提下，可将圆盘移至a,b,c中任 一塔座上。
n后问题
在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象 棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线 上的棋子。n后问题等价于在n×n格的棋盘上放置n个皇后， 任何2个皇后不放在同一行或同一列或同一斜线上。
（2）求解子问题：各子问题的解法与原问题的解法通常是相同的，可以用递 归的方法求解各个子问题，有时递归处理也可以用循环来实现。
（3）合并：把各个子问题的解合并起来，合并的代价因情况不同有很大差 异，分治算法的有效性很大程度上依赖于合并的实现。
divide-and-conquer(P) { if ( | P | <= n0) adhoc(P); //解决小规模的问题，直接求解 divide P into smaller subinstances P1,P2,...,Pk；//分解问题 for (i=1,i<=k,i++) yi=divide-and-conquer(Pi); //递归求解各子问题 return merge(y1,...,yk); //将各子问题的解合并为原问题的解 }
=
n/2
n
n/2 n/2
T(n/4)T(n/4)T(n/4)T(n/4) T(n/4)T(n/4)T(n/4)T(n/4) T(n/4)T(n/4)T(n/4)T(n/4) T(n/4)T(n/4)T(n/4)T(n/4
算法总体思想
将求出的小规模的问题的解合并为一个更大规模的问 题的解，自底向上逐步求出原来问题的解。[0:n-1]，现要在这n个元素中找 出一特定元素x。 算法复杂度分析： 据此容易设计出二分搜索算法： 每执行一次算法的 public static int binarySearch(int [] a, int x, int n) while循环， 待搜索数 { 组的大小减少一半。因 // 在 a[0] <= a[1] <= ... <= a[n-1] 中搜索 x // 找到x时返回其在数组中的位置，否则返回-1 此，在最坏情况下， int left = 0; int right = n - 1; while循环被执行了 while (left <= right) { O(logn) 次。循环体内 int middle = (left + right)/2; 运算需要O(1) 时间， if (x == a[middle]) return middle; if (x > a[middle]) left = middle + 1; 因此整个算法在最坏情 else right = middle - 1; 况下的计算时间复杂性 } 为O(logn) 。 return -1; // 未找到x