算法第二章递归与分治策略小结
第2章 递归与分治策略
2.1.递归的概念
递归算法：直接或间接地调用自身的算法
递归函数：用函数自身给出定义的函数
！！！！递归函数的第一句一定是if语句作为边界条件，然后就是递归方程
如：阶乘函数的第一句就是if条件语句
1 int factorial(int n){ 2 if( n ==0) 3 return 1; 4 return n*factorial(n-1); 5 }
※※※递归函数中比较著名的是Hanoi塔问题
Hanoi塔问题。 设a,b,c是3个塔座。开始时，在塔座a上有一叠共n个圆盘，这些圆盘自下而上，由大到小地叠在一起。各圆盘从小到大编号为1,2,…,n,现要求将塔座a上的这一叠圆盘移到塔座c上，并仍按同样顺序叠置。在移动圆盘时应遵守以下移动规则： 规则1：每次只能移动1个圆盘； 规则2：任何时刻都不允许将较大的圆盘压在较小的圆盘之上； 规则3：在满足规则1和2的前提下，可将圆盘移至a,b,c中任一塔座上。
1 #include<iostream> 2 using namespace std; 3 void move(char p1,char p2){ 4 cout<<p1<<"->"<<p2<<endl; 5 } 6 7 //将a上的n个盘子经b移动到c上 8 void hanoi(int n,char a,char b,char c){ 9 if(n == 0) return;//当a上没有盘子的时候，直接返回不需要移动 10 if(n == 1) move(a,c);//当a上只有一个盘子的时候，直接将盘子从a上移动到c上 11 if(n>1){ 12 hanoi(n-1,a,c,b); 13 move(a,b); 14 hanoi(n-1,c,b,a); 15 } 16 } 17 18 int main(){ 19 char x,y,z; 20 x = 'a'; 21 y = 'b'; 22 z = 'c'; 23 hanoi(4,x,y,z); 24 return 0; 25 }
2.2分治法的基本思想
分治法的基本思想：将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同
！！！在使用分治法设计算法的时候，最好使子问题的规模大致相同，即将一个问题分为大小相等的k个子问题，一般情况k取2.
※※※分治法中比较著名的是划分整数问题
1、整数划分问题 将一个正整数n表示为一系列正整数之和， n = n1 + n2 +…+nk 其中n1≥n2≥…≥nk≥1, k≥1。 例如 p(6) = 11 ，即整数6的划分数为11种： 6, 5+1, 4+2, 4+1+1, 3+3, 3+2+1, 3+1+1+1, 2+2+2, 2+2+1+1, 2+1+1+1+1, 1+1+1+1+1+1 2、有时候，问题本身具有比较明显的递归关系，因而容易用递归函数直接求解。 在本例中，如果设p(n)为正整数n的划分数，则难以直接找到递归关系。 因此考虑增加一个自变量：在正整数的所有不同划分中，将最大加数n不大于m的划分个数记为q(n, m)
递归关系：
1 #include<iostream> 2 using namespace std; 3 4 int q(int n,int m){ 5 if((n<1)||(m<1)) return 0; 6 if((n==1)||(m==1)) return 1; 7 if(n<m) return q(n,n); 8 if(n == m) return 1+q(n,n-1); 9 if(n>m) return q(n,m-1)+q(n-m,m); 10 } 11 12 int main(){ 13 int n,m; 14 cin >> n >> m; 15 cout << q(n,m); 16 return 0; 17 }
2.3.二分搜索技术
1 #include<iostream> 2 using namespace std; 3 4 int bsearch(int x,int a[],int left,int right){ 5 if(left>right) return -1; 6 int middle = (left+right)/2; 7 if(x == a[middle]) 8 return middle; 9 if(x < a[middle]) 10 return bsearch(x,a,left,middle-1); 11 else 12 return bsearch(x,a,middle+1,right); 13 } 14 15 int main(){ 16 int x; 17 cin >> x;//要找的特定元素 18 int n; 19 cin >> n; 20 int a[n]; 21 for(int i=0;i<n;i++){ 22 cin >> a[i]; 23 } 24 cout << bsearch(x,a,a[0],a[x-1]); 25 return 0; 26 }
时间复杂度分析：
1.前面两个if+int 一共三个语句 时间复杂度为3
2.后面两个if 时间复杂度是T（n/2）如果继续划分下去将会是T（n/4），T（n/8）.....
T（n）= 3+ T(n/2) = 3+3+T(n/4) =........= 4log n + 4 =O(log n)
1 #include<iostream> 2 using namespace std; 3 4 int bsearch(int x,int a[],int left,int right){ 5 while(left <= right){ 6 int middle = (left+right)/2; 7 if(x == a[middle]) 8 return middle; 9 if(x < a[middle]) 10 right = middle -1; 11 else 12 left = middle +1; 13 } 14 return -1; 15 } 16 17 int main(){ 18 int a[10] = {1,2,3,4,5,6,7,8,9,10}; 19 cout << bsearch(3,a,1,10); 20 return 0; 21 }
时间复杂度分析：
每执行一次算法的while循环，待搜索数组的大小减小一半。因此，在最坏情况下，while循环执行了O（log n）次。循环体内运算需要O（1）时间，因此整个算法在最坏情况下时间复杂度为O（log n）
※※※※分治法的时间复杂度
2.4大整数的乘法
题目：设X和Y都是n位的十进制整数。如果用常规的乘法计算乘积XY，其时间复杂性为O(n2)。
分治法的做法：
将X和Y都分成2段，即 X = A10n/2 + B, Y = C10n/2 + D
于是: XY = (A10n/2 + B)(C10n/2 + D) = AC10n +(AD+BC)10n/2 + BD
分析：
最终的时间复杂度跟按常规方法是一样的，因此这种方法不可行
※※※改进：减少乘法的运算次数
大整数的乘法的方法：
将XY改写成： XY = AC10n +((A–B)(D–C)+AC+BD)10n/2 + BD
仅需做3次n/2位整数的乘法（AC，BD，（(A-B)(D-C)）
T(n) = 3T(n/2) + O(n) = O(nlog23) = O(n1.59)
2.5.Strassen矩阵乘法
常规方法：
两个n×n矩阵乘法的时间复杂性为 O(n3)
分治法：
※※※ 改进：
※※※※※※
分治法和大整数乘法，Strassen矩阵乘法的区别
分治法是将问题分为两个子问题通过递归来降低时间复杂度，而解决大整数乘法和Strassen矩阵乘法如果也用分治的思想的话就时间复杂度依旧很大，因此我们需要继续降低时间复杂度，方法是减少乘法的次数，因此我们把问题分为3,4..个子问题来减少乘法的次数，从而降低时间复杂度
2.6.棋盘覆盖（不是重点）
2.7.合并排序
基本思想：用分治策略实现对n个元素进行排序的算法，将待排序元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最终将排好序的子集合合并成要求的排好序的集合
参考：(1条消息)归并排序算法 C++ - summerlq的博客 - CSDN博客 https://blog.csdn.net/summerlq/article/details/81284928对合并排序进行逻辑分析
1 #include<iostream> 2 using namespace std; 3 4 void merge(int a[],int l,int mid,int r) { 5 int b[1000]; 6 int i = l; 7 int j = mid+1; 8 int k = 0; 9 /*两段数组分别进行排序将排好序的数组放入数组b中*/ 10 while(i <= mid && j<=r){ 11 if(a[i]<a[j]){ 12 b[k] = a[i]; 13 i++; 14 } 15 else{ 16 b[k] = a[j]; 17 j++; 18 } 19 k++; 20 } 21 if(i<=mid){ 22 //如果i<=m则证明第一段数组没有全部放入数组b中，即第二段数组已全部放入数组b中，而第一段数组已经排好序只需逐一放入数组b即可 ,else情况同理 23 for(int p =i;p<=mid;p++){ 24 b[k++] = a[p]; 25 } 26 } else{ 27 for(int p =j;p<=r;p++){ 28 b[k++] = a[p]; 29 } 30 } 31 for(int p =l;p<=r;p++){ 32 a[p] = b[p-l];//将排好序的b数组复制到a数组中 33 } 34 } 35 36 /*将数组a分成两个部分，对每个部分递归调用mergesort进行排序，然后将两段排好序的数组进行合并到另一个数组b中*/ 37 void mergesort(int a[],int l,int r){ 38 if(r<=l) return;//如果数组中少于两个元素，则直接返回 39 int mid = (l+r)/2; 40 mergesort(a,l,mid); 41 mergesort(a,mid+1,r); 42 merge(a,l,mid,r); 43 } 44 45 46 int main(){ 47 int a[10] = {10,4,9,33,88,34,78,66,56,43}; 48 cout<<"原数组序列是："; 49 for(int i=0;i<10;i++){ 50 cout << a[i]<<" "; 51 } 52 cout<<endl; 53 cout<<"排序后数组序列是：" ; 54 mergesort(a,0,9); 55 for(int i=0;i<10;i++){ 56 cout << a[i]<<" "; 57 } 58 return 0; 59 }
时间复杂度分析：
2.8快速排序
2.9线性时间选择
2.10最接近点问题
2.11循环赛日程表
（以上的8,9,10,11节都非本章重点）
---恢复内容结束---
第2章 递归与分治策略
目录
2.1.递归的概念
递归算法：直接或间接地调用自身的算法
递归函数：用函数自身给出定义的函数
！！！！递归函数的第一句一定是if语句作为边界条件，然后就是递归方程
如：阶乘函数的第一句就是if条件语句
1 int factorial(int n){ 2 if( n ==0) 3 return 1; 4 return n*factorial(n-1); 5 }
※※※递归函数中比较著名的是Hanoi塔问题
Hanoi塔问题。 设a,b,c是3个塔座。开始时，在塔座a上有一叠共n个圆盘，这些圆盘自下而上，由大到小地叠在一起。各圆盘从小到大编号为1,2,…,n,现要求将塔座a上的这一叠圆盘移到塔座c上，并仍按同样顺序叠置。在移动圆盘时应遵守以下移动规则： 规则1：每次只能移动1个圆盘； 规则2：任何时刻都不允许将较大的圆盘压在较小的圆盘之上； 规则3：在满足规则1和2的前提下，可将圆盘移至a,b,c中任一塔座上。
1 #include<iostream> 2 using namespace std; 3 void move(char p1,char p2){ 4 cout<<p1<<"->"<<p2<<endl; 5 } 6 7 //将a上的n个盘子经b移动到c上 8 void hanoi(int n,char a,char b,char c){ 9 if(n == 0) return;//当a上没有盘子的时候，直接返回不需要移动 10 if(n == 1) move(a,c);//当a上只有一个盘子的时候，直接将盘子从a上移动到c上 11 if(n>1){ 12 hanoi(n-1,a,c,b); 13 move(a,b); 14 hanoi(n-1,c,b,a); 15 } 16 } 17 18 int main(){ 19 char x,y,z; 20 x = 'a'; 21 y = 'b'; 22 z = 'c'; 23 hanoi(4,x,y,z); 24 return 0; 25 }
2.2分治法的基本思想
分治法的基本思想：将一个规模为n的问题分解为k个规模较小的子问题，这些子问题相互独立且与原问题相同
！！！在使用分治法设计算法的时候，最好使子问题的规模大致相同，即将一个问题分为大小相等的k个子问题，一般情况k取2.
※※※分治法中比较著名的是划分整数问题
1、整数划分问题 将一个正整数n表示为一系列正整数之和， n = n1 + n2 +…+nk 其中n1≥n2≥…≥nk≥1, k≥1。 例如 p(6) = 11 ，即整数6的划分数为11种： 6, 5+1, 4+2, 4+1+1, 3+3, 3+2+1, 3+1+1+1, 2+2+2, 2+2+1+1, 2+1+1+1+1, 1+1+1+1+1+1 2、有时候，问题本身具有比较明显的递归关系，因而容易用递归函数直接求解。 在本例中，如果设p(n)为正整数n的划分数，则难以直接找到递归关系。 因此考虑增加一个自变量：在正整数的所有不同划分中，将最大加数n不大于m的划分个数记为q(n, m)
递归关系：
1 #include<iostream> 2 using namespace std; 3 4 int q(int n,int m){ 5 if((n<1)||(m<1)) return 0; 6 if((n==1)||(m==1)) return 1; 7 if(n<m) return q(n,n); 8 if(n == m) return 1+q(n,n-1); 9 if(n>m) return q(n,m-1)+q(n-m,m); 10 } 11 12 int main(){ 13 int n,m; 14 cin >> n >> m; 15 cout << q(n,m); 16 return 0; 17 }
2.3.二分搜索技术
1 #include<iostream> 2 using namespace std; 3 4 int bsearch(int x,int a[],int left,int right){ 5 if(left>right) return -1; 6 int middle = (left+right)/2; 7 if(x == a[middle]) 8 return middle; 9 if(x < a[middle]) 10 return bsearch(x,a,left,middle-1); 11 else 12 return bsearch(x,a,middle+1,right); 13 } 14 15 int main(){ 16 int x; 17 cin >> x;//要找的特定元素 18 int n; 19 cin >> n; 20 int a[n]; 21 for(int i=0;i<n;i++){ 22 cin >> a[i]; 23 } 24 cout << bsearch(x,a,a[0],a[x-1]); 25 return 0; 26 }
时间复杂度分析：
1.前面两个if+int 一共三个语句 时间复杂度为3
2.后面两个if 时间复杂度是T（n/2）如果继续划分下去将会是T（n/4），T（n/8）.....
T（n）= 3+ T(n/2) = 3+3+T(n/4) =........= 4log n + 4 =O(log n)
1 #include<iostream> 2 using namespace std; 3 4 int bsearch(int x,int a[],int left,int right){ 5 while(left <= right){ 6 int middle = (left+right)/2; 7 if(x == a[middle]) 8 return middle; 9 if(x < a[middle]) 10 right = middle -1; 11 else 12 left = middle +1; 13 } 14 return -1; 15 } 16 17 int main(){ 18 int a[10] = {1,2,3,4,5,6,7,8,9,10}; 19 cout << bsearch(3,a,1,10); 20 return 0; 21 }
时间复杂度分析：
每执行一次算法的while循环，待搜索数组的大小减小一半。因此，在最坏情况下，while循环执行了O（log n）次。循环体内运算需要O（1）时间，因此整个算法在最坏情况下时间复杂度为O（log n）
※※※※分治法的时间复杂度
2.4大整数的乘法
题目：设X和Y都是n位的十进制整数。如果用常规的乘法计算乘积XY，其时间复杂性为O(n2)。
分治法的做法：
将X和Y都分成2段，即 X = A10n/2 + B, Y = C10n/2 + D
于是: XY = (A10n/2 + B)(C10n/2 + D) = AC10n +(AD+BC)10n/2 + BD
分析：
最终的时间复杂度跟按常规方法是一样的，因此这种方法不可行
※※※改进：减少乘法的运算次数
大整数的乘法的方法：
将XY改写成： XY = AC10n +((A–B)(D–C)+AC+BD)10n/2 + BD
仅需做3次n/2位整数的乘法（AC，BD，（(A-B)(D-C)）
T(n) = 3T(n/2) + O(n) = O(nlog23) = O(n1.59)
2.5.Strassen矩阵乘法
常规方法：
两个n×n矩阵乘法的时间复杂性为 O(n3)
分治法：
※※※ 改进：
※※※※※※
分治法和大整数乘法，Strassen矩阵乘法的区别
分治法是将问题分为两个子问题通过递归来降低时间复杂度，而解决大整数乘法和Strassen矩阵乘法如果也用分治的思想的话就时间复杂度依旧很大，因此我们需要继续降低时间复杂度，方法是减少乘法的次数，因此我们把问题分为3,4..个子问题来减少乘法的次数，从而降低时间复杂度
2.6.棋盘覆盖（不是重点）
2.7.合并排序
基本思想：用分治策略实现对n个元素进行排序的算法，将待排序元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最终将排好序的子集合合并成要求的排好序的集合
参考：(1条消息)归并排序算法 C++ - summerlq的博客 - CSDN博客 https://blog.csdn.net/summerlq/article/details/81284928对合并排序进行逻辑分析
1 #include<iostream> 2 using namespace std; 3 4 void merge(int a[],int l,int mid,int r) { 5 int b[1000]; 6 int i = l; 7 int j = mid+1; 8 int k = 0; 9 /*两段数组分别进行排序将排好序的数组放入数组b中*/ 10 while(i <= mid && j<=r){ 11 if(a[i]<a[j]){ 12 b[k] = a[i]; 13 i++; 14 } 15 else{ 16 b[k] = a[j]; 17 j++; 18 } 19 k++; 20 } 21 if(i<=mid){ 22 //如果i<=m则证明第一段数组没有全部放入数组b中，即第二段数组已全部放入数组b中，而第一段数组已经排好序只需逐一放入数组b即可 ,else情况同理 23 for(int p =i;p<=mid;p++){ 24 b[k++] = a[p]; 25 } 26 } else{ 27 for(int p =j;p<=r;p++){ 28 b[k++] = a[p]; 29 } 30 } 31 for(int p =l;p<=r;p++){ 32 a[p] = b[p-l];//将排好序的b数组复制到a数组中 33 } 34 } 35 36 /*将数组a分成两个部分，对每个部分递归调用mergesort进行排序，然后将两段排好序的数组进行合并到另一个数组b中*/ 37 void mergesort(int a[],int l,int r){ 38 if(r<=l) return;//如果数组中少于两个元素，则直接返回 39 int mid = (l+r)/2; 40 mergesort(a,l,mid); 41 mergesort(a,mid+1,r); 42 merge(a,l,mid,r); 43 } 44 45 46 int main(){ 47 int a[10] = {10,4,9,33,88,34,78,66,56,43}; 48 cout<<"原数组序列是："; 49 for(int i=0;i<10;i++){ 50 cout << a[i]<<" "; 51 } 52 cout<<endl; 53 cout<<"排序后数组序列是：" ; 54 mergesort(a,0,9); 55 for(int i=0;i<10;i++){ 56 cout << a[i]<<" "; 57 } 58 return 0; 59 }
时间复杂度分析：
2.8快速排序
参考文献：(1条消息)快速排序算法的C++实现 - xuezhu1的博客 - CSDN博客 https://blog.csdn.net/xuezhu1/article/details/81944875
(1条消息)算法之快速排序（C++实现） - lyl771857509的博客 - CSDN博客 https://blog.csdn.net/lyl771857509/article/details/78845221
思想：是基于分治策略的另一种排序算法。其基本思想是，对于输入的子数组a[p:r]，按一下三个步骤进行排序：
①分解：以a[p]为基准元素将a[p:r]划分为3段a[p:q-1],a[q]和a[q+1:r]，使a[p:q-1]中任何一个元素小于等于a[q]，而a[q+1:r]中任何一个元素大于等于a[q]。下标q在划分过程中确定
②递归分解：通过递归调用快速排序算法，分别对a[p:q-1],a[q+1:r]进行排序
③合并：由于对a[p:q-1]和a[q+1:r]的排序是就地进行的，因此在a[p:q-1]和a[q+1:r]都排好序后，不需要执行任何算法，a[p:r]已经排好序
1 #include<iostream> 2 using namespace std; 3 4 void Swap(int x,int y){ 5 int t; 6 t = x; 7 x = y; 8 y = t; 9 } 10 11 int Partition(int a[],int p,int r){ 12 int i = p,j = r; 13 int x = a[p];// x 为基准数 14 //将小于x的元素交换到左边区域，将大于x的元素交换到右边区域 15 while(true){ 16 /*左边的数小于基准数，右边的数大于基准数的时候 不作处理*/ 17 while(a[++i] < x && i<r); 18 while(a[--j] > x && i<r); 19 if(i >= j) 20 break; 21 Swap(a[i],a[j]); 22 } 23 a[p] = a[j]; 24 a[j] = x; 25 return j; 26 } 27 28 void QuickSort(int a[],int p,int r){ 29 if(p<r){ 30 int q =Partition(a,p,r); 31 QuickSort(a,p,q-1);//对左半段进行排序 32 QuickSort(a,q+1,r);//对右半段进行排序 33 } 34 } 35 36 int main(){ 37 int a[5] = {1,2,9,7,0}; 38 cout << "原序列是："; 39 for(int i=0;i<5;i++){ 40 cout <<a[i]<<" "; 41 } 42 QuickSort(a,0,4); 43 cout << endl << "快排后的序列是："; 44 for(int i=0;i<5;i++){ 45 cout << a[i]<<" "; 46 } 47 return 0; 48 }
2.9线性时间选择
2.10最接近点问题
2.11循环赛日程表
（以上的9,10,11节都非本章重点）
