递归算法

递归算法

递归特点是：函数调用它自己本身。其中直接调用自己称为直接递归，而将a调用b，b又调用a的递归叫做间接递归。

例1.
给定n(n>=1)，用递归的方法计算1+2+3+4＋ …＋(n-1)＋n。


     
本题可以用递归方法求解，其原因在于它符合递归的三个条件：

     
（1）本题是累加问题：当前和＝前一次和 ＋ 当前项，而前一次和的计算方法与其相同，只是数据不同s(n) =s(n-1) + n；

     
（2）给定n，所以是有限次的递归调用；

     
（3）结束条件是当n = 1时，则s = 1。

程序如下：
    #include<iostream>
    using namespace std;
    int fac(int);        //递归函数 
    int main()
    {
        int t;
        cin>>t;
        cout<<"s="<<fac(t);
        return 0; 
    }
    int fac(int n){
    	if(n==1) return 1;
    	return fac(n-1)+n      //调用下一层递归 
    }
    
    运行程序，当t=5时，输出结果：s=15，其递归调用执行过程是：（设t =3)

     
递归调用过程，实质上是不断调用函数的过程，由于递归调用一次，所有子程序的变量（局部变量、变参等）、地址在计算机内部都有用特殊的管理方法————栈（先进后出）来管理，一旦递归调用结束，计算机便开始根据核中存储的地址返回各子程序变量的值，并进行相应操作。

 

例2.
设有n个数已经按从大到小的顺序排列，现在输入x，判断它是否在这n个数中，如果存在则输出 “YES”，再则输出 “ NO” 。

【算法分析】
    该问题属于数据的查找问题，数据查找有多种方法，通常方法是：顺序查找和二分查找，当N个数排好序时，用二分查找方法速度大大加快。
二分查找算法：
（1）设有n个数，存放在a数组中，待查找数为X，用L指向数据的高端，用R指向数据的低端，mid指向中间；
（2）若x= a[mid]，则输出 “ YES” ；
（3）若x<a[mid]，则到数据后半段查找：R不变，L= mid+l，计算新的mid值，并进行新的一段查找；
（4）若x>a[mid］，则到数据前半段查找：L不变，R= mid-1，计算新的mid值，并进行新的一段查找；
（5）若L>R都没有查找到，则输出“ NO” 。
该算法符合递归程序设计的基本规律，可以用递归方法设计。 

【参考程序】
    #include<iostream>
    using namespace std;
    int x,a[15];
    int search(int, int);        
    
    int main()
    {
        int l=1,r=10;
        for(int i=1; i<=10; i++)  cin>>a[i]; 
        cin>>x;
        
        search(l,r);
        return 0; 
    }
    
    int search(int l, int r){   //二分查找递归过程 
    	int m=(l+r)/2;      //求中间数的位置
    	if(l<=r){
    		if(x==a[m]) cout<<"YES";        //找到就输出
    	    else if(x>a[m]) search(m+1,r);     //判断在前半段还是后半段查找
    		else search(l,m-1); 
    	}
    	else cout<<"NO";
    }

 

例3.
用递归的方法求斐波那契数列中的第n个数。
 

#include<iostream>
using namespace std;
int a[15];
int fib(int);        

int main()
{
    int m;
    cin>>m;
    cout<<fib(m);
    return 0; 
}

int fib(int n){ 
	if(n==0) return 0;    //满足边界条件，递归返回 
	if(n==1) return 1;    //满足边界条件，递归返回
	return fib(n-1)+fib(n-2);    //递归公式，进一步递归 
}

 

例4.
集合的划分。
     
设S是一个具有n个元素的集合，S={al,a2，…,an}，现将S划分成k个满足下列条件的子集合Sl,S2,… ,Sk，且满足：
     
1.Si ≠ ∅
     
2.Si ∩ Sj = ∅           （l<=i, j<=k    i≠j）
     
3.S1∪S2∪S3∪...∪Sk = S

     
则称Sl,S2,… ，Sk是集合S的一个划分。它相当于把S集合中的n个元素al,a2,… ,an放入k个（O<k<=n<30）无标号的盒子中，使得没有一个盒子为空。 请你确定n个元素al,a2,…,an放入k个无标号盒子中去的划分数S(n,k）。


【输入样例】
  
10 6

【输入样例】
  
22827

【算法分析】
先举个例子，设S={l,2,3,4}，k=3，不难得出S有6种不同的划分方案，即划分数S(4,3)=6，具体方案为：
    {1,2}U{3}U{4}       {1,3}U{2}U{4}      {1,4}U{2}U{3} 
    {2,3}U{l}U{4}       {2,4}U{l}U{3}      {3,4}U{l}U{2} 
    
    考虑一般情况，对于任意的含有n个元素a1, a2, …, an的集合S，放入k个无标号的盒子中去，划分数为S(n,k），我们很难凭直觉和经验计算划分数和枚举划分的所有方案，
必须归纳出问题的本质。其实对于任一个元素an，则必然出现以下两种情况：
    1. {an｝是k个子集中的一个，于是我们只要把al，a2，...，an-1划分为k-1子集，便解决了本题，这种情况下的划分数共有S(n-l,k-1）个；
    2. {an｝不是k个子集中的一个，则an必与其他的元素构成一个子集。则问题相当于先al，a2，...，an-1划分成k个子集，这种情况下划分数共有S(n-1,k）个；然后再把元
    素an加入到k个子集中的任一个中去，共有k种加入方式，这样对于an的每一种加入方式，都可以使集合划分为k个子集，因此根据乘法原理，划分数共有k * S(n-1, k)个。

    综合上述两种情况，应用加法原理，得出n个元素的集合{al, a2, ..., an)划分为 k个子集的划分数位以下递归公式：S(n,k)=S(n-1,k-1) + k*S(n-1,k)   (n>k, k>0)。
    
    【参考程序】
    #include<iostream>
    using namespace std;
    int s(int, int);        
    
    int main()
    {
        int n,k;
        cin>>n>>k;
        cout<<s(n,k);
        return 0; 
    }
    
    int s(int n, int k){ 
    	if(n<k || k==0) return 0;  
    	if(k==1 || k==n) return 1;  
    	return s(n-1,k-1) + s(n-1,k)*k;    
    }

 

**例4.**数的计数。
     
我们要求找出具有下列性质数的个数（包括输入的自然数n）。 先输入一个自然数n(n<=1000），然后对此自然数按照如下方法进行处理 ：
     
不作任何处理；
     
在它的左边加上一个自然数，但该自然数不能超过原数的一半；
     
加上数后，继续按此规则进行处理，直到不能再加自然数为止。
     
【输入格式】
  
自然数n(n<=1000)

【输出格式】
  
满足条件的数

【输入样例】
  
6
( 满足条件的数为6

                        16

                        26

                      126

                        36

                      136 )

【输出样例】
  
6

【方法一】
用递归，f(n) = l+f(1)+f(2)+...+f(n/2)，当n较大时会超时，时间应该为指数级。
【参考程序】
#include<iostream>
using namespace std;

void dfs(int m){    //统计m所扩展出的数据个数
	num++;
	for(int i=1; i<=m/2; i++){    //左边添加不超过原数一半的自然数，作为新原数
		dfs(i);
	} 
}
int main()
{
    int n;
    cin>>n;
    dfs(n);
    cout<<num;
    return 0; 
}


【方法二】
    用记忆化搜索，实际上是对方法一的改进。设a[i]表示自然数i满足题意三个条件的数的个数。如果用递归求解，会重复来求一些子问题。例如在求a[4]时，需要再求
a[1]和a[2]的值。现在我们用a数组记录在记忆求解过程中得出的所有子问题的解，
    当遇到重叠子问题时，直接使用前面记忆的结果。
    【参考程序】
    #include<iostream>
    using namespace std;
    int a[1005];  
      
    void dfs(int m){
    	if(a[m]!=-1) return;   //说明前面已经求得a[m]的值，直接饮用即可，不需要再递归 
    	
    	a[m]=1;       //将h[m]置为1，表示m本身为一种情况 
    	for(int i=1; i<=m/2; i++){ 
    		dfs(i);
    		a[m]=a[i]+a[m];
    	}
    }
    
    int main()
    {
        int n;
        cin>>n;
        for(int i=1; i<=n; i++){
        	a[i]=-1;      //a数组初始化为-1 
    	}   
    	dfs(n);            //由顶到下记忆化递归求解 
        cout<<a[n];
        return 0; 
    }




【方法三】
    用递推，用a(n)表示自然数n所能扩展的数据个数，则a(l)=l, a(2)=2, a(3)=2, a(4)=4, a(5)=4, a(6)=6, a(7)=6, a(8)=10, a(9)=10。分析以上数据，可得递推公式：
a(i)=l+a(1)+a(2)＋…＋a(i/2)。此算法的时间度为O(n*n)。
    设a[i]-i按照规则扩展出的自然数个数(l<= i<= n)。下表列出了a[i］值及其方案：
    i        a[i]          自然数序列
    1          1            1
    2          2            2 12
    3          2            3 13
    4          4            4 14 24 124
    5          4            5 15 25 125
   ...        ...           ...
   由于1为最小自然数，因此1无法扩展出其他自然数。自然数i (l<= i<= n)按照规则扩展出的自然数包括自然数i；i左边加上1；i左边加上2按规则扩展出的a[2]个自然数…；
   由于i左邻的自然数不超过[i/2]，因此直至i左边加上a[[i/2]]个自然数（这些自然数由[i/2]按规则扩展出）为止。由此得出递推公式：
   a[1]=1
   a[i]=1+a(1)+a(2)＋…＋a(i/2)   (2<=i<=n)
   
   【参考程序】
    #include<iostream>
    using namespace std;
    int a[1005];    
    int main()
    {
        int n;
        cin>>n;
        
        a[1]=1;
        for(int i=1; i<=n; i++){
        	a[i]=1;
        	for(int j=1; j<=i/2; j++){
        		a[i]=a[j]+a[i];
        	}
    	}
        cout<<a[n];
        return 0; 
    }


【方法四】
    还是用递推，只要仔细分析，其实我们还可以得到以下的递推公式：
    （1）当i为奇数时，a[i]=a[i-1];
    （2）当i为偶数时，a[i]=a[i-1]+a[i]
    【参考程序】
    #include<iostream>
    using namespace std;
    int a[1005];  
    int main()
    {
        int n;
        cin>>n;
        a[1]=1;
        for(int i=2; i<=n; i++){
        	a[i]=a[i-1];
    		if(i%2==0)  a[i]=a[i-1]+a[i/2];
    	}          
        cout<<a[n];
        return 0; 
    }