古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，

    小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？   

   1.程序分析：   兔子的规律为数列1,1,2,3,5,8,13,21....

这是一道递归题。好了。睡觉了。明天等你公布答案了

递归，斐波拉侧数列

1. public class Rabbit {
   
2.         public static void main(String[] args) {
   
3.                 long f1, f2;
   
4.                 int i;
   
5.                 f1 = f2 = 1;
   
6.                 for (i = 1; i <= 20; i++) {
   
7.                         System.out.println(f1 + "\r\n" + f2);
   
8.                         f1 = f1 + f2; // 前两个月加起来赋值给第三个月
   
9.                         f2 = f1 + f2; // 前两个月加起来赋值给第三个月
   
10.                 }
    
11.         }
    
12. }

复制代码

递归算法。

这个是斐波那切数列！这是基础测试吧？

:D，好吧，看来不用我公布答案了！觉得简单的做做那位点评兄弟加的料啊！必须用递归，且在运行程序后1秒之内算出第50个月的兔子数
我想了一下，不会做!我太菜了！求解答！

M单色调 发表于 2014-8-1 00:51
这个是斐波那切数列！这是基础测试吧？

不知道啊，书上看的题目！

我用c做过，递归……

这算不算做出来了？

1. package test;
   
2. 
   
3. public class Test19 {
   
4.         public static void main(String[] args) {
   
5.                
   
6.                 for (int i = 0; i <= 50; i++) {
   
7.                         try {
   
8.                                 test(i);
   
9.                         } catch (Exception e) {
   
10.                                 continue;
    
11.                         }
    
12.                 }
    
13.                
    
14.         }
    
15.         
    
16.         public static void test(int num) {
    
17.                 long start = System.currentTimeMillis();
    
18.                 long count = rabbitMethod(num);
    
19.                 long end = System.currentTimeMillis();
    
20.                 System.out.println("第"+num+"个月会有"+count+"对兔子，计算耗时"+(end-start)+"毫秒");
    
21.         }
    
22.         
    
23.         public static long rabbitMethod(int num){
    
24.                 if(num<1) {
    
25.                         throw new RuntimeException("操作错误，错误操作数："+num);
    
26.                 }
    
27.                 if (num<3) {
    
28.                         return 1;
    
29.                 } else {
    
30.                         long f1 = 1, f2 = 1;
    
31.                         return getCount(2,num,f1,f2);
    
32.                 }
    
33.                
    
34.         }
    
35. 
    
36.         private static long getCount(int now, int num, long f1, long f2) {
    
37.                 if(now == num) {
    
38.                         return f2;
    
39.                 }
    
40.                 return getCount(now+1, num, f2, f1+f2);
    
41.         }
    
42. }
    

复制代码

那递归实际上就是个while循环，可以合并成这样

1.         public static long rabbitMethod(int num){
   
2.                 if(num<1) {
   
3.                         throw new RuntimeException("操作错误，错误操作数："+num);
   
4.                 }
   
5.                 if (num<3) {
   
6.                         return 1;
   
7.                 } else {
   
8.                         long f1 = 1, f2 = 1;
   
9.                         long temp = 0;
   
10.                         int now = 2;
    
11.                         while (now<num) {
    
12.                                 temp = f1 + f2;
    
13.                                 f1 = f2;
    
14.                                 f2 = temp;
    
15.                                 now++;
    
16.                         }
    
17.                         return f2;
    
18.                 }
    
19.                
    
20.         }

复制代码

高手自在民间啊！

黄宝宝 发表于 2014-8-1 01:13
，好吧，看来不用我公布答案了！觉得简单的做做那位点评兄弟加的料啊！必须用递归，且在运行程序后1秒之 ...

不用递归也能做

黄宝宝 发表于 2014-8-1 01:14
不知道啊，书上看的题目！

我的基础测试就有这道提。。

等着公布答案

怎么觉得我好像见过

  就是斐波那契数列，我基础测试做过