归专题
我个人认为递归是算法中很重要的武器,虽然递归的效率很慢,但他是我们学习其他算法的基础,而递归这一算法又很抽象,也很难调试,所以我认为我有必要要这里好好理解递归这一有力的武器。。
表达式的转化:
#include<cstdio>
#include<iostream>
#include<math.h>
#include <string>
using namespace std;
double calc()
{
}
int main()
{
}
逆波兰表达式:
//#include<isotream> #include<cstdio> #include<math.h> using namespace std; double exp() { char a[10]; scanf("%s",a); switch(a[0]){ case'+':return exp()+exp(); case'-':return exp()-exp(); case'*':return exp()*exp(); case'/':return exp()/exp(); default:return atof(a); } } int main() { double ans; ans=exp(); printf("%f",ans); return 0; }
Time Limit: 1000MS | Memory Limit: 10000K | |
Total Submissions: 17936 | Accepted: 11317 |
Description
Input
Output
Sample Input
1 7 3Sample Output
8Source
很好的算法:
f(m, n) = f(m-n, n) + f(m, n-1)
f(m, n): 把m个苹果放到n个盘子中的方法数
f(m, n-1): 把m个苹果放到n-1个盘子中的方法数(其中至少有一个空盘子)
f(m-n, n): 把m个苹果放到n个盘子中,而且每个盘子中都有苹果(先拿n个出来,等m-n个放好了,然后每个盘子放一个)
#include
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/2f88ce130b654eb5dc6788e02dbcfc90.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/0ac3a2d53663ec01c7f7225264eeefae.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/2f88ce130b654eb5dc6788e02dbcfc90.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/f70a0fde2b51b7dd92a70e712e540cf6.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/4a5daaec04350a363f186a4d2c5ed6ce.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/0ac3a2d53663ec01c7f7225264eeefae.gif)
Time Limit: 1000MS | Memory Limit: 30000K | |
Total Submissions: 14298 | Accepted: 7416 |
Description
Write a program to count the number of black tiles which he can reach by repeating the moves described above.
Input
There are H more lines in the data set, each of which includes W characters. Each character represents the color of a tile as follows.
'.' - a black tile
'#' - a red tile
'@' - a man on a black tile(appears exactly once in a data set)
The end of the input is indicated by a line consisting of two zeros.
Output
Sample Input
6 9 ....#. .....# ...... ...... ...... ...... ...... #@...# .#..#. 11 9 .#......... .#.#######. .#.#.....#. .#.#.###.#. .#.#..@#.#. .#.#####.#. .#.......#. .#########. ........... 11 6 ..#..#..#.. ..#..#..#.. ..#..#..### ..#..#..#@. ..#..#..#.. ..#..#..#.. 7 7 ..#.#.. ..#.#.. ###.### ...@... ###.### ..#.#.. ..#.#.. 0 0
Sample Output
45 59 6 13
Source
上面的return 1+f(x-1,y)+f(x+1,y)+f(x,y+1)+f(x,y-1)这里属于递推公式,这时比如要计算f(x,y)的时,这时就会向这f(x-1,y)这个方向一直深搜下去,一直到f(x-1,y)这个方向没有地方可以走了,这时就要在当前的位置继续深搜f(x-1,y)这个方向,接着就会继续深搜f(x-1,y)这个方向,同样直到f(x-1,y)这个方向不能再进行时,继续深搜f(x+1,y)这个方向,直到这个方向无路可走,就继续深搜f(x,y+1)这个方向.......一直递归下去。到了最后一个方向不行时,这时就要返回上一层继续搜这个方向还未搜到的点.....一直的返回,阅读这个代码应该好理解点:
#include<stdio.h>
int n,m;
char s[21][21];
int visit[21][21];
int count;
void dfs(int x,int y)
{
}
int main (void)
{
}
下面再来看一个问题,就是
记得在我们最开始学习C语言的时候,每当讲到递归,无论是课本上,还是老师,都会给出两个经典例子的递归实现,其中一个就是阶乘,另外一个就是Fibonacci(中文多译成斐波那契)数列了。
用递归方法计算阶乘的代码如下:
//递归计算阶乘
long Factorial(int n)
{
}
这样的递归是一个很明显的尾部递归的例子,所谓的尾部递归(tail recursion),即递归调用是函数执行的最后一项任务,函数在递归调用返回之后不再做任何事情。尾部递归可以很方便的转换成一个简单循环,完成相同 的任务,这样,就将一个递归的实现转化成了非递归实现。
以下是阶乘算法的非递归实现:
//计算阶乘的非递归实现
long Factorial(int n)
{
}
单从这个改写来看,我们无法看出这样的改写有多大的意义。但是有些时候,递归并不是一种很好的解决问题的方法,最常见的一个问题就是深度递归会造成堆栈溢出的错误!有时候递归还会导致程序效率的下降,下面要说的Fibonacci数列,就是一个很好的反例。
Fibonacci数列使用递归的定义(呃。。。定义就不给了),这种定义容易诱导我们使用递归形式来编程解决这个问题。下面是一个Fibonacci的递归实现,很容易就看懂了,呵呵,就是定义的程序版本:
//递归计算Fibonacci数列的值
typedef unsigned long ulong;
ulong Fiblnacci(int n)
{
}
这样的程序是非常简捷的,有时候,递归的程序实现看上去要比非递归的实现简捷得多。这个时候,你需要在效率和程序的可读性和可维护性上做一些取舍。
这个Fibonacci的递归实现在计算值时,每次递归调用都触发另外两个递归,而这两个递归在调用的时候每个都还要触发两外的两个递归调用,再接 下去的调用也是如此。现在,我们知道,这个冗余的递归调用是以几何级数增长的。例如,在递归计算Fibonacci(10)时,Fibonacci(3) 的值被计算了21次。
为什么会是21次呢,这里可以打个比方,比如当要计算F(10)时,这时F(10)就会吩咐下去计算F(9)的值F(9)就会吩咐去计算F(8)的值,F(8)就会吩咐计算F(7)的值,一直下去,当到F(2)时,这时返回1的值回来,接着就要返回上一层,这时F(3)又吩咐计算F(1)的值,F(1)又返回1的值回来,这时F(3)的值就确定下来了,接着F(3)心里默念的它的值把它交给了F(4),可是F(4)又要吩咐去算F(2)的值,这时F(2)又返回了1,这时F(4)的值为F(3)+F(2);这时F(4)默念着它的值,又把它的值交给了F(5),这时F(5)又要命令去算F(3)的值,这时F(3)又要递归它的值,算出它的值后再交给F(5);这时F(5)默念着他的值然后交给F(6),这时F(6)又要吩咐去算F(4)的值,此时F(4)就又得吩咐去算F(3)与F(2)的值,这样不断的进行下去,F(3)的值会不断的被命令去算,所以会有21次。这里足见其效率之低。。
而在递归计算Fibonacci(30),这个调用的次数是骇人的317811次!这些个计算实际上只有一次是必要的,其余的纯属浪 费!
下面的程序使用一个简单循环来代替递归,这个非递归的形式不如上文给出的递归简单(当然,这个也很简单),也不太符合Fibonacci的递归定义,但是,它的效率提高了几十万倍!
//Fibonacci数列的非递归实现
typedef unsigned long ulong;
ulong Fibonacci(int n)
{
}
所以,本文的结论就是,当你使用递归实现一个函数之前,先问问自己使用递归的好处是否抵得上它的代价。当然,编程的时候,无论什么实现方式,我们都应该问问自己这个问题。
斐波那契数列最初出现是计算兔子的数目,所以又被称为“兔子数列”,所以看到农夫养牛等问题,还是可以联系上的。
关于斐波那契的讨论,主要集中在对其的优化,以及其扩展题目上,递归已经由只有一项在变,变成两项在变了。其扩展的题目,如何得到递归式,如何透过现象来将递归式写出来,才是真正的要点。
包括农夫养牛问题,爬楼梯问题,打靶问题等等,应该算起来都算是斐波那契问题的一些扩展。
【扩展】
1. 一个农夫养了一头牛,三年后,这头牛每年会生出1头牛,生出来的牛三年后,又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢
老外喜欢养牛,在很多题目中都可以看到奶牛还是什么牛的身影。这道题目的网址为:
http://topic.csdn.net/u/20091001/15/40bf4993-8ed7-45cc-968f-97c524dae3c4.html?80749
而前段时间园子中有兄弟已经详细探讨了这个问题。
http://www.cnblogs.com/chinese-zmm/archive/2009/10/31/1593586.html
关于这个问题,其实一开始遇到是使用模拟的思路去想的,而且想得比较的糊涂,因为牛生下来之后,并不是马上就可以生小牛,是在三年后,每年生一头牛,那假设某一年,就有能生小牛的,还有一年生小牛的,还有两年生小牛的,然后就自己把自己绕住了。
但是,其实没有这么复杂,就是将其分为能生小牛的和不能生小牛的。
从而得到:
今年的牛的数目=去年的牛的数目+三年前牛的数目
也就是f(n)=f(n-1)+f(n-3)
这里
f(n-2) 第一年
f(n-1) 第二年
f(n) 第三年
看了一下题目,应该是三年后,那就应该是n-3。
代码如下:
1 #include <iostream>
2 using namespace std;
3
4 int Fibonacci(int n)
5 {
6 if (n==1 || n==2 || n==3)
7
8 return 1;
9
10 return Fibonacci(n-1)+Fibonacci(n-3);
11 }
12
13 int main()
14 {
15
16 }
这里计算F(10)的道理跟之前一样的,F(10)这一年的值是由F(9)和F(7)这两年的和得来的,这时F(10)就会吩咐去计算F(9 )的值,F(9)又会吩咐去计算F(8)的值.......一直到F(3)的值,这时就会返回F(3)的值给F(4),此时F(4)又要吩咐去计算F(2)的值,即算出F(4)的值后默念交给F(5),这时F(5)又要吩咐去计算F(2)的值,此时F(2)返回它的值给F(5),则F(5)的值就是F(2)+F(4)的值,接着F(5)默念的它的值交给了F(6),此时F(6)又要吩咐去计算F(4)的值,F(4)又要重新递归一次,就这样不断的进行下去。
这里输入参数为n+1,是因为是n年后的数目,所以需要加1。
这道题目,也可以使用数组将运算的结果保存下来,然后直接进行计算,这就是常说的动态规划。
代码如下:
1 int Fibonacci2(int n)
2 {
3 int *num=new int[n];
4
5 for (int i=3;i<n;i++)
6
7
8
9 int ret=num[n-1];
10
11 return ret;
12 }
13
14 int main()
15 {
16
17 }
2. 打靶问题: 一个人打靶,成绩为0~10之间的任意一个整数。包括0和10。一共打了10次总共得分89分。问得分的可能性。
可以得到比较明显的一个递归式,f(n)=x+f(n-1),而x的取值为0-10之间的任意一个整数。
所以我们需要去做一个变化的x,其实也就是一个循环来得到。
因为要求的结果为得分的可能性,所以我们要将结果保存起来,然后每遇到结果为89的,则将保存的结果打印出来,然后统计+1,所以我们需要一个10个数的数组来做这件事情。
递归终止条件是当n为0时终止,此时来判断分值并进行相应的操作。
1 #include <iostream>
2 using namespace std;
3
4 int countresult;
5 int store[10];
6
7
8 void getscore(int sum, int n)
9 {
10 if(sum<0 || sum+(n+1)*10<89 || sum>89)
11 return;
12 if(n==0)
13
14 //check the number
15 if(sum==89)
16
17 for(int i=0;i<10;i++)
18
19
20
21
22 return;
23
24 for(int i=0;i<=10;i++)
25
26
27
28
29 }
30
这里的递归就类似深搜了,这里不再多解释。
31 int main()
32 {
33
34
35 return 0;
36 }
注意上面的代码,其实上面还是应用了递归中常使用的一种做法--剪枝。
上面的代码并不太好,比较好的是下面的代码,但是两种方法作出的值是一样的。
1 #include <iostream>
2 using namespace std;
3
4 int sum;
5 int store[10];
6
7 void Output()
8 {
9 for(int i = 9; i>=0; --i)
10
11
12
13
14 ++sum;
15 }
16
17 void Cumput(int score, int num)
18 {
19 if(score < 0 || score > (num+1)*10 ) //次数num为0~9
20 return;
21 if(num == 0)
22
23
24
25 return;
26
27 for(int i = 0; i <= 10; ++i)
28
29
30
31
32 }
33
34 int main(int argc, char* argv[])
35 {
36
37
38 return 0;
39 }
3. 爬楼梯问题:
一个N级的楼梯,一个人每次可以爬一级,也可以爬两级,问如果给定一个N要求输出所有的爬楼方法,并统计出方法数 。
可 以思考,在第n级的时候,可以通过f(n-1)爬1级得到,也可以通过f(n-2)爬两级得到,如果f(n-2)爬1级,也就是又到f(n- 1),其实是涵盖在前面一种情况下的。所以得到递归公式: f(n)=f(n-1)+f(n-2),很明显,得到递归公式后,就是斐波那契数列。
再扩展,如果每次可以爬一级,也可以爬两级,也可以爬三级。那此时递归公式怎么推?
此时就要加上f(n-3)的情况,而f(n-3)上面爬2级,爬1级,又回到f(n-2)或者f(n-1),所以得到递归式为
f(n)=f(n-1)+f(n-2)+f(n-3)
关于斐波那契的类似问题很多,但是如何思考得到递归式是重点,当得到正确的递归式后,就明白是斐波那契,那就能够直接使用斐波那契相关的方法来做该问题了。
最后有一道思考题,是概率题:
一副52张的牌(去掉大小鬼),4张A排在一起的概率是多少?
为 了避免误解题意,将原题也放在这里 (A deck of 52 cards is shuffled thoroughly. What is the probability that the 4 aces are all next to each other?)
从中选择:
(a) 4!49!/52!
(b) 1/52!
(c) 4!/52!
(d) 4!48!/52!
(e) 都不是
(f) 是未知的
递归算法详解
C通过运行时堆栈支持递归函数的实现。递归函数就是直接或间接调用自身的函数。
从这些关系中,我们很容易看出在余数上加上‘0’就可以产生对应字符的代码。接着就打印出余数。下一步再取商的值,4267/10等于426。然后用这个值重复上述步骤。
这种处理方法存在的唯一问题是它产生的数字次序正好相反,它们是逆向打印的。所以在我们的程序中使用递归来修正这个问题。
我们这个程序中的函数是递归性质的,因为它包含了一个对自身的调用。乍一看,函数似乎永远不会终止。当函数调用时,它将调用自身,第2次调用还将调用自身,以此类推,似乎永远调用下去。这也是我们在刚接触递归时最想不明白的事情。但是,事实上并不会出现这种情况。
这个程序的递归实现了某种类型的螺旋状while循环。while循环在循环体每次执行时必须取得某种进展,逐步迫近循环终止条件。递归函数也是如此,它在每次递归调用后必须越来越接近某种限制条件。当递归函数符合这个限制条件时,它便不在调用自身 。
在程序中,递归函数的限制条件就是变量quotient为零。在每次递归调用之前,我们都把quotient除以10,所以每递归调用一次,它的值就越来越接近零。当它最终变成零时,递归便告终止。
#include <stdio.h>
int binary_to_ascii( unsigned int value)
{
}
递归是如何帮助我们以正确的顺序打印这些字符呢?下面是这个函数的工作流程。
3. 接着,打印步骤1中除法运算的余数
注意在第2个步骤中,我们需要打印的是quotient当前值的各位数字。我们所面临的问题和最初的问题完全相同,只是变量quotient的 值变小了。我们用刚刚编写的函数(把整数转换为各个数字字符并打印出来)来解决这个问题。由于quotient的值越来越小,所以递归最终会终止。
一旦你理解了递归,阅读递归函数最容易的方法不是纠缠于它的执行过程,而是相信递归函数会顺利完成它的任务。如果你的每个步骤正确无误,你的限制条件设置正确,并且每次调用之后更接近限制条件,递归函数总是能正确的完成任务。
但是,为了理解递归的工作原理,你需要追踪递归调用的执行过程,所以让我们来进行这项工作。追踪一个递归函数的执行过程的关键是理解函数中所声 明的变量是如何存储的。当函数被调用时,它的变量的空间是创建于运行时堆栈上的。以前调用的函数的变量扔保留在堆栈上,但他们被新函数的变量所掩盖,因此 是不能被访问的。
当递归函数调用自身时,情况于是如此。每进行一次新的调用,都将创建一批变量,他们将掩盖递归函数前一次调用所创建的变量。当我追踪一个递归函数的执行过程时,必须把分数不同次调用的变量区分开来,以避免混淆。
程序中的函数有两个变量:参数value和局部变量quotient。下面的一些图显示了堆栈的状态,当前可以访问的变量位于栈顶。所有其他调用的变量饰以灰色的阴影,表示他们不能被当前正在执行的函数访问。
假定我们以4267这个值调用递归函数。当函数刚开始执行时,堆栈的内容如下图所示:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/6c599c4fe3acfa50ebcc8ad60488c774.jpeg)
执行除法之后,堆栈的内容如下:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/67d854ec3d0e67f1d52d07b999f9e8f0.jpeg)
接着,if语句判断出quotient的值非零,所以对该函数执行递归调用。当这个函数第二次被调用之初,堆栈的内容如下:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/62fd874fa15da75206ff02b6678ee3d5.jpeg)
堆栈上创建了一批新的变量,隐藏了前面的那批变量,除非当前这次递归调用返回,否则他们是不能被访问的。再次执行除法运算之后,堆栈的内容如下:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/e62f8aad764484537d9921fa79a00d98.jpeg)
quotient的值现在为42,仍然非零,所以需要继续执行递归调用,并再创建一批变量。在执行完这次调用的出发运算之后,堆栈的内容如下:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/722fc4003759f61e8445d2600cb7cc45.jpeg)
此时,quotient的值还是非零,仍然需要执行递归调用。在执行除法运算之后,堆栈的内容如下:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/9750d066df2af022079b15728a894ce9.jpeg)
不算递归调用语句本身,到目前为止所执行的语句只是除法运算以及对quotient的值进行测试。由于递归调用这些语句重复执行,所以它的效果 类似循环:当quotient的值非零时,把它的值作为初始值重新开始循环。但是,递归调用将会保存一些信息(这点与循环不同),也就好是保存在堆栈中的 变量值。这些信息很快就会变得非常重要。
现在quotient的值变成了零,递归函数便不再调用自身,而是开始打印输出。然后函数返回,并开始销毁堆栈上的变量值。
每次调用putchar得到变量value的最后一个数字,方法是对value进行模10取余运算,其结果是一个0到9之间的整数。把它与字符常量‘0’相加,其结果便是对应于这个数字的ASCII字符,然后把这个字符打印出来。
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/9750d066df2af022079b15728a894ce9.jpeg)
接着函数返回,它的变量从堆栈中销毁。接着,递归函数的前一次调用重新继续执行,她所使用的是自己的变量,他们现在位于堆栈的顶部。因为它的value值是42,所以调用putchar后打印出来的数字是2。
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/602b84e06891c2e004cd4cd42f934740.jpeg)
接着递归函数的这次调用也返回,它的变量也被销毁,此时位于堆栈顶部的是递归函数再前一次调用的变量。递归调用从这个位置继续执行,这次打印的数字是6。在这次调用返回之前,堆栈的内容如下:
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/59c10325fda0cfcfff76665dd98587da.jpeg)
现在我们已经展开了整个递归过程,并回到该函数最初的调用。这次调用打印出数字7,也就是它的value参数除10的余数。
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/ac693c5ace177cd0d4bf167c0592cbc8.jpeg)
然后,这个递归函数就彻底返回到其他函数调用它的地点。
如果你把打印出来的字符一个接一个排在一起,出现在打印机或屏幕上,你将看到正确的值:4267
汉诺塔问题递归算法分析:
一个庙里有三个柱子,第一个有64个盘子,从上往下盘子越来越大。要求庙里的老和尚把这64个盘子全部移动到第三个柱子上。移动的时候始终只能小盘子压着大盘子。而且每次只能移动一个。
1、此时老和尚(后面我们叫他第一个和尚)觉得很难,所以他想:要是有一个人能把前63个盘子先移动到第二个柱子上,我再把最后一个盘子直接移 动到第三个柱子,再让那个人把刚才的前63个盘子从第二个柱子上移动到第三个柱子上,我的任务就完成了,简单。所以他找了比他年轻的和尚(后面我们叫他第 二个和尚),命令:
3、第三个和尚接了任务,又把移动前61个盘子的任务依葫芦话瓢的交给了第四个和尚,等等递推下去,直到把任务交给了第64个和尚为止(估计第64个和尚很郁闷,没机会也命令下别人,因为到他这里盘子已经只有一个了)。
4、到此任务下交完成,到各司其职完成的时候了。完成回推了:
第64个和尚移动第1个盘子,把它移开,然后第63个和尚移动他给自己分配的第2个盘子。
第64个和尚再把第1个盘子移动到第2个盘子上。到这里第64个和尚的任务完成,第63个和尚完成了第62个和尚交给他的任务的第一步。
从上面可以看出,只有第64个和尚的任务完成了,第63个和尚的任务才能完成,只有第2个和尚----第64个和尚的任务完成后,第1个和尚的任务才能完成。这是一个典型的递归问题。 现在我们以有3个盘子来分析:
第1个和尚命令:
很显然,第二步很容易实现(哎,人总是自私地,把简单留给自己,困难的给别人)。
其中第一步,第2个和尚他有2个盘子,他就命令:
同样,第二步很容易实现,但第3个和尚他只需要移动1个盘子,所以他也不用在下派任务了。(注意:这就是停止递归的条件,也叫边界值)
第三步可以分解为,第2个和尚还是有2个盘子,命令:
分析组合起来就是:1→3 1→2 3→2 借助第三个柱子移动到第二个柱子 |1→3 自私人留给自己的活| 2→1 2→3 1→3 借助第一个柱子移动到第三个柱子|共需要七步。
如果是4个盘子,则第一个和尚的命令中第1步和第3步各有3个盘子,所以各需要7步,共14步,再加上第1个和尚的1步,所以4个盘子总共需要移动 7+1+7=15步,同样,5个盘子需要15+1+15=31步,6个盘子需要31+1+31=64步……由此可以知道,移动n个盘子需要(2的n次 方)-1步。
从上面整体综合分析可知把n个盘子从1座(相当第一柱子)移到3座(相当第三柱子):
(1)把1座上(n-1)个盘子借助3座移到2座。
(3)把2座上(n-1)个盘子借助1座移动3座。
下面用hanoi(n,a,b,c)表示把1座n个盘子借助2座移动到3座。
很明显:
用C语言表示出来,就是:
#include <stdio.h>
int method(int n,char a, char b)
{
}
int hanoi(int n,char a,char b,char c)
{
}
int main()
{
}
递推:
献给杭电五十周年校庆的礼物
Time Limit: 2000/1000 MS (Java/Others)Total Submission(s): 3580
或许你依然心怀忧伤
或许你近在咫尺
或许你我天各一方
对于每一个学子
母校
永远航行在
生命的海洋
今年是我们杭电建校五十周年,这是一个值得祝福的日子。我们该送给母校一个怎样的礼物呢?对于目前的大家来说,最好的礼物当然是省赛中的好成绩,我不能参赛,就送给学校一个DOOM III球形大蛋糕吧,这可是名牌,估计要花掉我半年的银子呢。
想象着正式校庆那一天,校长亲自操刀,把这个大蛋糕分给各地赶来祝贺的校友们,大家一定很高兴,呵呵,流口水了吧...
等一等,吃蛋糕之前先考大家一个问题:如果校长大人在蛋糕上切了N刀(校长刀法极好,每一刀都是一个绝对的平面),最多可以把这个球形蛋糕切成几块呢?
做不出这个题目,没有蛋糕吃的!
为-了-母-校-,为-了-蛋-糕-(不是为了DGMM,枫之羽最会浮想联翩...),加-油-!
用带定系数法求出各个系数就OK了,不用想破脑筋找规律。。。。。。
(n * n * n + 5*n) / 6 + 1;
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/2f88ce130b654eb5dc6788e02dbcfc90.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/f70a0fde2b51b7dd92a70e712e540cf6.gif)
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
10
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
11
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/4a5daaec04350a363f186a4d2c5ed6ce.gif)
12
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/df37983f39daa189b8c814e01a6a9011.gif)
13
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/0ac3a2d53663ec01c7f7225264eeefae.gif)
14
![递归专题 递归专题](https://i-blog.csdnimg.cn/blog_migrate/cbef093dcc044b2793832001e2365e43.gif)