斐波那契数列 农夫养牛问题

记下来自己看的。

问题： （CSDN上看到的）

一个农夫养了一头牛，三年后，这头牛每年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……问农夫10年后有多少头牛?n年呢？



这个问题的数学模型是： 斐波那契数列（兔子序列）。



斐波那契数列指的是这样一个数列：1、1、2、 3、5、8、13、21、……

　 这个数列从第三项开始，每一项都等于前两项之和。它的通向公式为：(1/√5)*{[(1+√5)/2]^n - [(1-√5)/2]^n}（又叫“比内公式”，是用无理数表示有理数的一个范例。）（√5表示根号5）



这个是数学公式的：






Java代码

1. public class Fibonacci
2. {
3. 　　public static void main(String[] args)
4. 　　{
5. 　　 int x=1,y=1;
6. 　　 System.out.println(x+" ");
7. 　　 for(int i=1; i<=10; i++)
8. 　　 {
9. 　　 System.out.println(y+" ");
10. 　　 y=x+y;
11. x=y-x;
12. 　　 }
13. 　　}
14. }

public class Fibonacci
{
　　public static void main(String[] args)
　　{
　　 int x=1,y=1;
　　 System.out.println(x+" ");
　　 for(int i=1; i<=10; i++)
　　 {
　　 System.out.println(y+" ");
　　 y=x+y;
x=y-x;
　　 }
　　}
}

看起来很简单 根据公式来。



这个是递归的：


Java代码

1. private int Fibonacci(num)
2. {
3. 　　if(num <= 2){
4. 　　 return 1;
5. 　　}else{
6. 　　 return Fibonacci(num - 1) + Fibonacci(num - 2)
7. 　　}
8. }
9.
10. public static void main(String[] args)
11. {
12. Fibonacci(10);
13. }

private int Fibonacci(num)
{
　　if(num <= 2){
　　 return 1;
　　}else{
　　 return Fibonacci(num - 1) + Fibonacci(num - 2)
　　}
}

public static void main(String[] args)
{
Fibonacci(10);
}



也是根据公式来的。





这个是面向对象的：
Java代码

1. class Cow
2. {
3. private int age;
4.
5. public Cow()
6. {
7. age = 0;
8. }
9.
10. public Cow bearCow()//生小牛
11. {
12. return new Cow();
13. }
14.
15. public void grow()//每年牛龄加1
16. {
17. age = age + 1;
18. }
19.
20. public int getAge()
21. {
22. return age;
23. }
24. }
25. public class Main {
26. private static Set <Cow> cowSet = new HashSet <Cow>();//牛圈，存放所有的牛
27.
28. public static int check()// 每年检测一边所有的牛，年龄要加一，并且够岁数了要生效牛
29. {
30. Set <Cow> newCowSet = new HashSet <Cow>();
31. for(Cow cow : cowSet)
32. {
33. cow.grow();//年龄加一
34. if(cow.getAge() >= 3)
35. newCowSet.add(cow.bearCow());//够岁数的生小牛
36.
37. }
38. cowSet.addAll(newCowSet);//把所有生出来的小牛放牛圈里
39. return cowSet.size();
40. }
41. public static void main(String args[])
42. {
43. Cow cow = new Cow();
44. cowSet.add(cow);
45. for(int i = 0; i < 10; i ++)
46. {
47. System.out.println(i+1 + " : " + check());
48. }
49. }
50.
51. }

class Cow
{
private int age;

public Cow()
{
age = 0;
}

public Cow bearCow()//生小牛
{
return new Cow();
}

public void grow()//每年牛龄加1
{
age = age + 1;
}

public int getAge()
{
return age;
}
}
public class Main {
private static Set <Cow> cowSet = new HashSet <Cow>();//牛圈，存放所有的牛

public static int check()//每年检测一边所有的牛，年龄要加一，并且够岁数了要生效牛
{
Set <Cow> newCowSet = new HashSet <Cow>();
for(Cow cow : cowSet)
{
cow.grow();//年龄加一
if(cow.getAge() >= 3)
newCowSet.add(cow.bearCow());//够岁数的生小牛

}
cowSet.addAll(newCowSet);//把所有生出来的小牛放牛圈里
return cowSet.size();
}
public static void main(String args[])
{
Cow cow = new Cow();
cowSet.add(cow);
for(int i = 0; i < 10; i ++)
{
System.out.println(i+1 + " : " + check());
}
}

}

看起来有点傻。不过现实中遇到的可能都会这么写。不是我写的 呵呵。





相关的一个问题：



有一段楼梯有10级台阶,规定每一步只能跨一级或两级,要登上第10级台阶有几种不同的走法?

　　这就是一个斐波那契数列：登上第一级台阶有一种登法；登上两级台阶，有两种登法；登上三级台阶，有三种登法；登上四级台阶，有五种登法……

　　1，2，3，5，8，13……所以，登上十级，有89种走法。有一段楼梯有10级台阶,规定每一步只能跨一级或两级,要登上第10级台阶有几种不同的走法?

　　这就是一个斐波那契数列：登上第一级台阶有一种登法；登上两级台阶，有两种登法；登上三级台阶，有三种登法；登上四级台阶，有五种登法……

　　1，2，3，5，8，13……所以，登上十级，有89种走法。





代码是抄来的没有测试过。