斐波那契數列 農夫養牛問題

記下來自己看的。

問題： （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種走法。





代碼是抄來的沒有測試過。