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

记下来自己看的。

问题： （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种走法。





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