想想也就是在强调算法，这是我的算法，用递归做的，是通过画图，一个一个写出出生的牛，然后获得第几天有多少牛，然后在总结规律得出的，比较笨。
分析过程：Axx带表对Ax的第几个孩子.

1. /**
   
2. * 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
   
3. * 问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
   
4. * @author Lihsh-PC
   
5. *
   
6. */
   
7. public class Test {
   
8. 
   
9.         /**
   
10.          * @param args
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 //十年后实际上是第十一年
    
14.                 //n年后也就是第n+1年
    
15.                 System.out.println("你想知道n年后有多少头牛，那请先输入n吧：");
    
16.                 Scanner scanner = new Scanner(System.in);
    
17.                 int years = scanner.nextInt();
    
18.                 System.out.println(years + "年后有"+ getSum(years + 1) +"头牛");
    
19.         }
    
20.         /**
    
21.          * 由题目可以知道：对于每一头牛单独而言，增长规律是1、2、3、4、5，6从第三项开始是一个等差数列 (可以看出从第四天看是，该天的牛数为第三天，第二天，第一天的牛之和)
    
22.          * 从第四天开始出生的牛又要重复上述的等差数列                  0、0、0、1、2、3、4(已在第一头牛中计算了father)（和上面是一样的道理）
    
23.          * 第五天出生的牛。。                                                                                        0、0、0、1、2、3、4()(已在第一头牛中计算了father)（和上面是一样的道理）
    
24.          * -----------------------------------------------------------
    
25.          *                                                                 1、1、1、2、3、4、6、9....
    
26.          * 其实也就是兔子(斐波纳契数列)出生的问题的变种,最后我们得出的结论就是第n(n>4)天的牛数量是第(n-2)天,第(n-3)天,第(n-4)天的牛数量之和
    
27.          * 即f(n)=f(n-2)+f(n-3)+f(n-4)(n > 4)
    
28.          * f(1)=1
    
29.          * f(2)=1
    
30.          * f(3)=1
    
31.          * 或者f(n)=1 n<4
    
32.          * f(4) = 2
    
33.          * 由上面的分析可以看出，是一个递归的问题
    
34.          * @param years 多少年后
    
35.          */
    
36.         public static int getSum(int years){
    
37.                 if(years == 0)
    
38.                         return 0;
    
39.                 else if(years >= 1 && years <= 3)
    
40.                         return 1;
    
41.                 else if(years > 3)
    
42.                         return getSum(years -2) + getSum(years -3) + getSum(years -4);
    
43.                 else
    
44.                         System.out.println("输入有误，请重新输入！");
    
45.                 return years;
    
46.         }
    
47. }

复制代码

学习学习了。

你看,你自己图片里计算的结果与你计算出来的结果都不一样.

斐波纳契数列

1. public class PruduceCattle {
   
2. 
   
3.         /** 一个农夫养了一头牛，三年后，这头牛每一年会生出1头牛，生出来的牛三年后，又可以每年生出一头牛……
   
4.          * 问农夫10年后有多少头牛?n年呢?(不考虑其他因素，只考虑此数学问题)
   
5.          * 规律:即f(n)=f(n-2)+f(n-3)+f(n-4)(n > 4);这个用递归效率奇低.
   
6.          * 我找的规律:f(n)=f(n-1)+f(n-3);(n>3)
   
7.          * @param args
   
8.          */
   
9.         public static void main(String[] args) {
   
10.                 // TODO Auto-generated method stub
    
11.                 Long begin=System.currentTimeMillis();
    
12.                 System.out.println(getCattleCount(1000));
    
13.                 System.out.println(System.currentTimeMillis()-begin+"毫秒");
    
14.                 /*50          1000
    
15.                 83316385      4.239507006748923E165
    
16.                 0毫秒                    31毫秒*/        
    
17.                 /*Long begin=System.currentTimeMillis();
    
18.                 System.out.println(getSum(50));//这是最快的,我开始试1000,结果有十几分钟没出结果.而上面的算法算1000,只需要32毫秒.
    
19.                 System.out.println(System.currentTimeMillis()-begin+"毫秒");*/
    
20.         }
    
21.         public static int getSum(int years) {
    
22.                 if (years == 0)
    
23.                         return 0;
    
24.                 else if (years >= 1 && years <= 3)
    
25.                         return 1;
    
26.                 else if (years > 3)
    
27.                         return getSum(years - 2) + getSum(years - 3) + getSum(years - 4);
    
28.                 else
    
29.                         System.out.println("输入有误，请重新输入！");
    
30.                 return years;
    
31.         }
    
32.         public static double getCattleCount(int n){
    
33.                 double sum=0;
    
34.                 double first=1;
    
35.                 double second=1;
    
36.                 double thread=1;
    
37.                 for(int i=0;i<n-3;i++){
    
38.                         sum=first+thread;
    
39.                         first=second;
    
40.                         second=thread;
    
41.                         thread=sum;
    
42.                 }
    
43.                 if(n<=3)
    
44.                         return 1;
    
45.                 else return sum;
    
46.         }
    
47.        
    
48. }
    

复制代码

陈圳 发表于 2013-4-13 11:07
你看,你自己图片里计算的结果与你计算出来的结果都不一样.

没有啊 我在程序注释的地方有说明了 十年后其实是第11年 图片里写的是每一年牛数量 写到第十年 没有写第11年而已

李松柏 发表于 2013-4-13 11:08
斐波纳契数列

必须嗯哪~~~

陈圳 发表于 2013-4-13 12:41

学习了 不错不错