3、递归与分治策略

一、算法思想

    1、递归思想：

    (1)要将求解的较大规模的问题分(divide)割成k个更小规模的子问题。对这k个子问题分别求解。如果子问题的规模仍然不够小，则再划分为k个子问题，如此递归(conquer)的进行下去，直到问题规模足够小，很容易求出其解为止。

    (2)将求出的小规模的问题的解合并(combine)为一个更大规模的问题的解，自底向上逐步求出原来问题的解。

    2、分治思想：

    将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

    3、分治法的适用条件

    (1)该问题的规模缩小到一定的程度就可以容易地解决

    (2)该问题可以分解为若干个规模较小的相同问题

    (3)利用该问题分解出的子问题的解可以合并为该问题的解

    (4)该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题（如果不是独立的，用动态规划）

    4、总结：

    直接或间接地调用自身的算法称为递归算法。

    用函数自身给出定义的函数成为递归函数。

    由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。在这种情况下，反复应用分治手段，可以使子问题与原问题类型一致而其规模却不断缩小，最终使子问题缩小到很容易直接求出其解。这自然导致递归过程的产生。

    分治和递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。

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); //将各子问题的解合并为原问题的解 }

二、入门

    1、兔子繁殖

    在一年之初，把性别相反的一对新生兔子放进围栏。从第二月开始，母兔每月生出一对性别相反的小兔。每对新生兔也从它们第二个月开始每月出生一对新兔。求一年后围栏内兔子的对数。

    同Fibonacci数列

    考虑：第一个月：1对

            第二个月：2对=原先的一对+新生的一对

            第三个月：3对=原先的两对+新生的一对

            第四个月：5对=原先的三对+新生的两对

    我们发现第四个月新生的就是第二个月的对数，因为第二个月那个新生的不能生，故到第三个月时，第二个月的兔子都能生了

    我没用递归，用的递推。。

    递归：

    设置临界条件x=1时，兔子1对，x=2时，兔子2对。

    递归函数f(x)=f(x-1)+f(x-2)

    #include <iostream> using namespace std; long fibonacci(int x) { if (x==1) return1; else if(x==2) return 2; else return(fibonacci(x-1)+fibonacci(x-2)); } int main(){ int n; cin>>n; cout>>endl>>fibonacci(n); return 0; } 

     2、排列问题

    生成n个元素{r1,r2,……,rn}的全排列

    思路：

    设R={r1,r2,……,rn}是要进行排列的n个元素，Ri=R-{ri}

    集合X中元素的全排列记为perm(X)。

    (ri)perm(X)表示在全排列perm(X)的每一个排列前加上前缀得到的排列。R的全排列可归纳定义如下：

    (1)当n=1时，perm(R)=(r)，其中r是集合R中唯一的元素

    (2)当n>1时，perm(R)由(r1)perm(R1)，(r2)perm(R2)，……，(rn)perm(rn)构成。 

    #include <iostream> #include <cstdlib> using namespace std; void swap(int & a,int & b) { int temp=a;a=b;b=temp; } void Perm(int list[],int k,int m) { if(k==m) { for(int i=0;i<=m;i++) cout<<list[i]<<" "; cout<<endl; } else for(int j=k;j<=m;j++) { swap(list[k],list[j]); Perm(list,k+1,m); swap(list[k],list[j]); } } int main() { int list[]={1,2,3,4,5,6}; Perm(list,0,3); system("pause"); return EXIT_SUCCESS; } /* 算法Perm(list,k,m)递归地产生所有前缀是list[0:k-1],且后缀是list[k:m]的全排列的所有排列 */

    1731 Orders 全排列

    #include <iostream> #include <vector> #include <string> #include <math.h> #include <iomanip> #include <stdlib.h> using namespace std; char input[200],output[200]; int used[200]; int group=0; int cmp(const void* a,const void* b) { return *(char*)a-*(char*)b; } void orderfun(int current,int length) //current代表当前打印第几个 { for (int i=0;i<length;i++) { if (i<length-1&&input[i]==input[i+1]&&used[i+1]==0) //重复则运行下一个,判断下一个是否用过很关键，若判断上一个则超时了。。。会走很多弯路 continue; if (used[i]==0) { output[current]=input[i]; used[i]=1; if (current==length-1) //打印一种排列 { printf("%s/n",output); } else orderfun(current+1,length); used[i]=0; } } } int main() { cin>>input; int len=strlen(input); qsort(input,len,sizeof(input[0]),cmp); memset(used,0,sizeof(used)); orderfun(0,len); }

3、整数划分问题

    将正整数n表示成一系列正整数之和：n=n1+n2+...+nk

    思路：

    在本例中，如果设p(n)为正整数n的划分数，则难以找到递归关系，因此考虑增加一个自变量：将最大加数n1不大于m的划分个数记作q(n,m)。可以建立q(n,m)的如下递归关系：

    (1)q(n,1)=1,n>=1

    当最大加数n1不大于1时，任何正整数n只有一种划分形式，即n=1+1+……+1，一共n个1.

    (2)q(n,m)=q(n,n),m>=n

    最大加数n1实际上不能大于n。因此q(1,m)=1

    (3)q(n,n)=1+q(n,n-1)

    正整数n的划分由n1=n的划分和n1<=n-1的划分组成。

    (4)q(n,m)=q(n,m-1)+q(n-m,m),n>m>1

    正整数n的最大加数n1不大于m的划分由n1=m的划分和n1<=m-1的划分组成

4、二分搜素

递归实现：

int bsearch(int low,int high,int x) { if(low>hight) return -1; int mid=(hight+low)/2; if(a[mid]==k) return mid; else if(a[mid]>k) return bsearch(low,mid-1,x); else return bsearch(mid+1,high,x); }

非递归：

 public static int binarySearch(int[] a,int x,int n) { //在a[0]~a[n-1]中搜索x //找到x时，返回其在数组中的位置，否则返回-1 int left=0,right=n-1; while(left<=right) { int middle=(left+right)/2; if(x==a[middle]) return middle; if(x>a[middle]) left=middle+1; else right=middle-1; } return -1; }

5、归并(Merge)排序

    是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

void MergeSortDC(int[] R,int low,int high) { int mid; if(low<high) { mid=(low+high)/2; MergeSortDC(R,low,mid); MergeSortDC(R,mid+1,high); Merge(R,low,mid,high); } } 

void Merge(int array[], int p, int q, int r) { 　　int i,k; 　　int begin1,end1,begin2,end2; 　　int* temp = (int*)malloc((r-p+1)*sizeof(int)); 　　begin1= p; 　　end1 = q; 　　begin2 = q+1; 　　end2 = r; 　　k = 0; 　　while((begin1 <= end1)&&( begin2 <= end2)) 　　{ 　　 if(array[begin1] < array[begin2]) 　　 { temp[k] = array[begin1]; 　　 begin1++; 　　 } 　　 else 　　 { 　　 temp[k] = array[begin2]; 　　 begin2++; 　　 } 　　 k++; 　　 } 　　 while(begin1<=end1) 　　 { 　　 temp[k++] = array[begin1++]; 　　 } 　　 while(begin2<=end2) 　　 { 　　 temp[k++] = array[begin2++]; 　　 } 　　 for (i = 0; i < (r - p + 1); i++) 　　 array[p+i] = temp[i]; 　　 free(temp); }  

6、快排