第三章 递归与分治策略

递归算法 

程序直接或间接调用自身的编程技巧称为递归算法。

 

递归算法优点

它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

 

递归算法缺点：

递归算法解题的运行效率较低。
在递归调用过程中，系统为每一层的返回点、局部变量等开辟了堆栈来存储。递归次数过多容易造成堆栈溢出等。

 

• 任何一个可以用计算机求解的问题所需的计算时间都与其规模n有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。
• 分治法的设计思想是，将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。
• 如果原问题可分割成k个子问题（1＜k≤n），且这些子问题都可解，并可利用这些子问题的解求出原问题的解，那么这种分治法就是可行的。
• 由分治法产生的子问题往往是原问题的较小模式，这就为使用递归技术提供了方便。

 

递归需要有边界条件、递归前进段和递归返回段。

当边界条件不满足时，递归前进；
当边界条件满足时，递归返回。
注意：在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口，否则将无限进行下去。

 

 

例题（Fibonacci数列）

int fib(int n)
{
	if (n<=1) return 1;
	return fib(n-1)+fib(n-2);
}

 

例题（集合的全排列问题）

 

//产生从元素k～m的全排列，作为前k—1个元素的后缀
void Perm(int list[], int k, int m)
{
	if(k==m) 	//构成了一次全排列，输出结果
	{
		for(int i=0;i<=m;i++)
			cout<<list[i]<<" ";
		cout<<endl;
	}
	else
		//在数组list中，产生从元素k～m的全排列
		for(int j=k;j<=m;j++)
		{
			swap(list[k],list[j]);
			Perm(list,k+1,m);
			swap(list[k],list[j]);
		}
}

 数组list[]＝{1, 2, 3, 4, 5, 6,7}，则调用Perm(list,2,4) 就是产生元素3～5的全排列。

 

 

例题（整数划分问题）

整数划分问题是算法中的一个经典命题之一。把一个正整数n表示成一系列正整数之和：

正整数n的这种表示称为正整数n的划分。正整数n的不同划分个数称为正整数n的划分数，记作正整数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

 

正整数n的划分数p(n)=f(n,n)

int split(int n,int m)
{
	if(n==1||m==1) return 1;
	else if (n<m) return split(n,n);
	else if(n==m) return split(n,n-1)+1;
	else return split(n,m-1)+split(n-m,m);
}

 

 

分治策略

• 分治策略是对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同。
• 递归地解这些子问题，然后将各子问题的解合并得到原问题的解。

 

 

分治法的基本步骤

• 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；
• 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题；
• 合并：将各个子问题的解合并为原问题的解。

Divide_and_Conquer（P）
{
	if (|P|＜＝n0 ) return adhoc(P)；
	divide P into smaller substances P1，P2，…，Pk；
	for (i＝1; i＜＝k; k＋＋) 
		yi＝Divide-and-Conquer（Pi）	     //递归解决Pi
	Return merge（y1，y2，…，yk）	    //合并子问题
}

 

 

 

采用分治策略求在a[left,right]中第k小的元素

int select(int left,int right,int k)  //采用分治策略求在a[left,right]中第k小的元素
{
    if(left>=right)     //找到了第k小的元素
       return a[left];
    int i=left;         //从左到右的指针
    int j=right+1;      //从右到左的指针
    int pivot=a[left];  //把最左边的元素作为分界数据
    while(true)         //把左侧大于等于pivot的元素与右侧小于等于pivot的元素交换
    {
        do              //在左侧寻找大于等于pivot的元素
        {
            i+=1;
        }while(a[i]<pivot);
        do               //在右侧寻找小于等于pivot的元素
        {
            j-=1;
        }while(a[j]>pivot);
        if(i>=j)          //没有发现交换对象
            break;
        swap(a[i],a[j]);
    }
    if(j-left+1==k)
        return pivot;
    a[left]=a[j];         //存储pivot
    a[j]=pivot;
    if(j-left+1<k)
        return select(j+1,right,k-j+left-1);    //对一个段进行递归调用
    else return select(left,j-1,k);
}

 

 

例题（半数集问题）

给定一个自然数n，由n开始可以依次产生半数集set(n)中的数如下。
(1) n 属于set(n)；
(2) 在n的左边加上一个自然数，但该自然数不能超过最近添加的数的一半；
(3) 按此规则进行处理，直到不能再添加自然数为止。
例如，set(6)={6，16，26，126，36，136}。
半数集set(6)中有6个元素。
注意半数集是多重集。
对于给定的自然数n，编程计算半数集set(n)中的元素个数。

 

设set(n)中的元素个数为，则显然有：

int comp(int n)
{
	int ans=1;
	if (n>1) for(int i=1;i<=n/2;i++)
		ans+=comp(i);
	return ans;
}

 

递归算法—记忆式搜索

int a[1001];
int comp(int n)
{
	int ans=1;
	if(a[n]>0)return a[n];		//已经计算
	for(int i=1;i<=n/2;i++)
		ans+=comp(i);
	a[n]=ans;				//保存结果
	return ans;
}