Algorithm-4-Divide and conquer

Void Story ( ) { printf(“从前有个庙，庙里有个老和尚，老和尚给小和尚讲故事， \r\n”)； printf(“讲的什么故事呢？故事是：\r\n”)； Story( ); }
生活中的递归─ 画中画
递归
1. 递归是一种特殊 的迭代，只不过它 在迭代前不知道要 迭代多少次；
2. 递归的函数调用 自身，而这个函数 一定有参数，且参 数会在迭代的过程 中不断变化，步步 逼近某个值； 3. 递归的函数中一 定有那么一个分支 是处理终点，而这 个点就是递归出口。
(3) for (i = 1, i <= k, i++)
yi = divide-and-conquer(Pi); //递归求解各子问题 (4) return merge(y1,...,yk); //将各子问题的解合并为原问题的解 }
设计划分策略，把原问题P分解成k个规模较小的子问题，这个步骤是 分治算法的基础和关键，人们往往遵循两个原则：
k
d log d log d log
k m k m k m
分治策略基本原理
划分策略是关键，总体上可以分为两大类： 1. 黑盒划分策略，此类方法根据问题的规模对原问题进行划分，而
不考虑划分对象的属性值，所以形象地称之为黑盒划分；
2. 白盒划分策略，此方法根据划分对象的特定属性值（也称之为参 照值）把对象集合划分为若干个子集。特别地，对于某些问题， 根据白盒划分策略分割的部分子集可以直接排除，而不需要求解， 可以认为减少了求解空间，称之为减治策略。
13 27 38 49 65 76 97
黑盒划分典型问题—合并排序
38
49
65
97
13
27
76
13
27
38
49
65
76
97
黑盒划分典型问题—合并排序
黑盒划分典型问题—合并排序
主程序：
黑盒划分典型问题—合并排序
49 38 65 97 76 13 27
49 38 65 97
76 13 27
49 38
李清勇
教授
引子-治国
治国
中国
黑龙江省
„„
北京市
„„
广东省
西城区
„„
海淀区
„„
东城区
„„
北下关街 道
„„
孙子兵法“凡治众如治寡，分数是也 ”
引子
治国 齐家
引子
治国
齐家
算法设计
10000000万个整数的排序 一个地图中10000000万个点，找出最近两个点
分治与递归
“分治合”策略
Divide Combine
√
√
√
Conquer
√
√
√
分治策略基本原理
divide-and-conquer(P){ (1) if ( | P | <= n0) adhoc(P); //递归出口，用特定程序解决基础问题 (2) divide P into smaller subinstances P1,P2,...,Pk；//分解出子问题
子问题
子问题
子问题
…
…
…
…
…
…
…
…
…
分治算法总体思想
治 — 求解规模足够小的子问题。 原问题
子问题
子问题
子问题
…
…
…
…
…
…
…
…
…
√ √ √ √ √ √ √ √
√ √ √ √ √ √ √ √ √ √ √ √ √ √ √ √
分治算法总体思想
合—将求出的小规模的问题的解合并为一个更大规模的问题的解，自底向上逐步 求出原来问题的解。
递归的两个要素
递归函数的两个基本要素

递归边界，也就是函数的初始值，每一个递归函数都必须具备非
递归定义的初始值，否则，递归函数就无法计算。

递推方程，用较小自变量的函数值来表示较大自变量的函数值，
它是递归求解的依据，体现分治策略的核心要素。
递归程序也包含类似的两部分 边界处理部分，它是递归出口，决定何时结束递归调用。
平衡子问题原则，分割出的k个子问题其规模最好大致相当；
独立子问题原则，分割出的k个子问题之间重叠越少越好，最好k个 子问题是相互独立，不存在重叠子问题。
分治策略基本原理
divide-and-conquer(P){ (1) if ( | P | <= n0) adhoc(P); //递归出口，用特定程序解决基础问题 (2) divide P into smaller subinstances P1,P2,...,Pk；//分解出子问题
黑盒划分典型问题—合并排序
任务描述：任意给定一包含n个整数的集合，把n个整数按升序排列。 输入：每测试用例包括两行，第一行输入整数个数，第二行输入n个整 数，数与数之间用空格隔开。最后一行包含-1，表示输入结束。 输出：每组测试数据的结果输出占一行，输出按升序排列的n个整数。 样例输入：
7 49 38 65 97 76 13 27 -1
第n个月的兔子对数为 F(n)，它们按兔子的成熟属性可以分为两类： 成熟兔子对 = ? 新生兔子对 = ?
递归实例-2
1 F (n) F (n 1) F (n 2) n 0,1 n 1
递归实例-3
Stirling数： n个元素的集合{1,2,…,n }可以划分为若干个非空子 集的集合。例如，当 n=3 时，集合{1， 2， 3}可以划分为 5个不同 的非空子集的集合如下： { {1}，{2}，{3} } { {1，2}，{3} } { {1，3}，{2} } { {2，3}，{1} } { {1，2，3} } 给定正整数n和 m，计算出 n个元素的集合 {1,2,…,n }可以划分为 多少个不同的由m个非空子集构成的集合。 比如上例中含有1个子集的集合有1个，2个子集的集合有3个，3个 子集的集合有1个。
65 97
76 13
49
38
65
97
76
13
27
38 49
65 97
13 76
38 49 65 97
13 27 76
13 27 38 49 65 76 97
黑盒划分典型问题—逆序对问题
黑盒划分典型问题—逆序对问题
枚举算法
时间复杂度是O(n^2) 当数组中元素的个数n比较少时，容易统计逆序对的数目 数组中只有1个元素的话，逆序对的数目为0； 数组中有2个元素，如果第一个元素大于第二个元素，则 有1个逆序对，否则0个逆序对。 数组中元素个数超过2，怎么办？
int factorial(int n){ // n = 3 if(n == 0) return 1; return n * factorial(n - 1); }
⑧
⑦
②
int factorial(int n){ // n = 2 if(n == 0) return 1; return n * factorial(n - 1); }
递归实例-3
递归实例-3
把n个不同苹果放入m个相同盘子中，不允许盘子为空，请问总共有多少种方法？
把n个相同苹果放入m个相同盘子中，不允许盘子为空，请问总共有多少种方法？
分治算法总体思想
分 — 将大规模的原问题分割成 k 个更小规模的子问题，如果子问题的规 模仍然不够小，则再划分为 k 个“子子”问题，如此递归地进行下去，直 到子问题规模足够小（基础问题），很容易求出其解为止。 原问题
黑盒划分典型问题—逆序对问题
黑盒划分典型问题—逆序对问题
C = C1 + C2 + C3
计算C3有两种方法：
黑盒划分典型问题—逆序对问题
38
49 A1
65
97
13
40 A2
76
38 > 13
38 < 40 49 > 40 49 < 76 65 < 76 97 > 76
{49, 65, 97} > 13
yi = divide-and-conquer(Pi); //递归求解各子问题
(4) return merge(y1,...,yk); //将各子问题的解合并为原问题的解 }
O(1) n 1 T (n) kT (n / m) f (n) n 1
分治策略基本原理
迭代求解：
(n log m ) T (n) (n dlog k ) m d (n )
其合并子程序也往往不一样。
分治策略基本原理
divide-and-conquer(P){ (1) if ( | P | <= n0) adhoc(P); //递归出口，用特定程序解决基础问题 (2) divide P into smaller subinstances P1,P2,...,Pk；//分解出子问题 (3) for (i = 1, i <= k, i++)
递归调用部分，它实现递归方程或递归操作过程。
递归实例-1
阶乘计算：从键盘输入正整数N（0<=N<=20),输出N!
边界条件
N 0 1 N! N ( N 1)! N 0
递归出口
递推方程
递归调用
①
int main(){ int x = factorial(3); cout << x << endl; return 0; }
③
⑥
int factorial(int n){ // n = 1 if(n == 0) return 1; return n * factorial(n - 1); }