益智题的递归：）

 题目如下：

 * 十个射击运动员打靶，靶一共有10环，10人打中90环的可能性有多少种？ 请用递归算法编程实现。

 

 

关于递归，其求解过程类似一个stack，先进后出。先是由上而下调用，直至寻找到出口，然后自下而上计算返回结果。

其关键点：

1.寻找到一个“出口”，就是递归表达式在这一步可以计算出一个值。

2.定义递归表达式。注意在定义表达式n的时候，下一步n-1往往被考虑成可解的结果。（类似数学的推论证明）

 

 

一。第一步 尝试

拿到这个题目分析了一下，然后写了第一版代码：

1.     /**
2.      * 递归计算函数
3.      * 
4.      * @param personId 人数,从0开始计算
5.      * @param currentScore  当前人打的环数，从0--10 
6.      * @param scoreHistory  环数记录
7.      */
8.     private static void Caculate(int personId,int currentScore,
9.             int[] scoreHistory) {
10.         
11.         //出口
12.         if( 0 == personId) {//.最后一个人的时候，离90还剩下0-10环即可以满足一次
13.             if(90-sumup(scoreHistory)> =0 && 90-sumup(scoreHistory)<=10) {
14.                 currentScore = 90-sumup(scoreHistory);
15.                 scoreHistory[personId] = currentScore;
16.                 printlog(scoreHistory);
17.             }
18.         }else { //迭代
19.             scoreHistory[personId] = currentScore;
20.             //计算下一个人，下个人可能打出0--10环，因此需要循环
21.             for(int i =0; i<=10;i++) {
22.                 Caculate(personId-1,i,scoreHistory);
23.             }
24.         }
25.     }

这个递归函数的出口也找到了，表达式也找到了，应该可以求解，对吧。继续下一步，貌似可以调用函数求解咯：）。。

1.     public static void main(String[] args) {
2.         for(int i =0; i<=10;i++) {
3.             Caculate(9,i,store);
4.         }
5.     }

做到这里才发现，原来这个递归居然没有入口，这里是犯了第一个错误。也就是调用函数的时候，以personId=9人为起点，可是这个人的currentScore是多少呢。。。居然还需要用一个for循环去尝试，效率显然让人无语。

 

二。第二步 修改

 

这时候考虑修改入口，虽然无法猜出第一个人打几环，但是可以肯定的是，总剩余环数为90。修改递归函数如下：

1.     /**
2.      * 递归函数
3.      * @param personId 人数,从0开始计算
4.      * @param remanentScore 当前剩余环数 <=90
5.      * @param scoreHistory 环数记录
6.      */
7.     private static void Caculate(int personId,int remanentScore
8.             ,int[] scoreHistory) {
9.         if(0 == personId) { //出口,最后一个人打出剩余环数就ok
10.             if(remanentScore>=0 && remanentScore<=10) {
11.                 scoreHistory[personId] = remanentScore;
12.                 printlog(scoreHistory);
13.                 counter++;
14.             }
15.         }else {
16.             for(int i=0; i<=10 ; i++) {//这个人可能打出0-10环
17.                 scoreHistory[personId] = i;
18.                 remanentScore -= i;
19.                 Caculate(personId-1,remanentScore,scoreHistory);
20.             }
21.         }
22.     }

这里就犯第二个错误了。。呵呵。18，19行的一个非常隐蔽的小bug，debug调了n久才发现！

错就错在将remanentScore进行了自减。通常在函数结尾处理一个不再使用的变量，没有什么影响的。但是这个递归函数进入到for循环，代表的是当前递归并未到出口，就是没有结束！变量的错误操作会影响到后面的计算。

 

解决办法就是将18，19两行改成    Caculate(personId - 1, remanentScore - i, scoreHistory); 传递正确的参数而不影响当前递归值栈

 

三。第三步 优化

第二步实现的递归，跟套10个for循环的效率应该是一样差。每种组合都需要跑一遍，判断。 而我们知道，如果前面2个人打了不到10环，后面8个人全中10也不可能达到90环。那么来优化一下递归函数。

1.     /**
2.      * 递归函数
3.      * @param personId 人数,从0开始计算
4.      * @param remanentScore 当前剩余环数 <=90
5.      * @param scoreHistory 环数记录
6.      */
7.     private static void Caculate(int personId,int remanentScore
8.             ,int[] scoreHistory) {
9.         if(remanentScore > (personId+1)*10) {
10.             return;
11.         }
12.         
13.         if(0 == personId) { //出口,最后一个人打出剩余环数就ok
14.             if(remanentScore>=0 && remanentScore<=10) {
15.                 scoreHistory[personId] = remanentScore;
16.                 printlog(scoreHistory);
17.                 counter++;
18.             }
19.         }else{
20.             for (int i = 0; i <= 10; i++) {//这个人可能打出0-10环
21.                 scoreHistory[personId] = i;
22.                 //              remanentScore-=i;
23.                 //              Caculate(personId-1,remanentScore,scoreHistory);
24.                 Caculate(personId - 1, remanentScore - i, scoreHistory);
25.             }
26.         }
27.     }

在函数开始就增加分数判断，不合适的直接pass 。

 

总共的循环次数为10的十次方10000000000 ，满足条件的次数仅92378，因此这一个简单的判断是惊天地泣鬼神的！

 

在我机器上运行优化过的递归时间为8688ms，而没有优化过的需要时间35766ms，显然是数量级的提高。

 

下面是最终JAVA代码：（改日写个Python的。。。好歹也算是混了个眼熟）

1. package datastructure;
3. /**
4.  * 十个射击运动员打靶，靶一共有10环，10人打中90环的可能性有多少种？ 请用递归算法编程实现
5.  * 请用递归算法编程实现
6.  * @author wei.songw
7.  * Sep 20, 2008 9:28:46 PM
8.  */
9. public class Shot {
10.     static int counter = 0;
12.     /**
13.      * 打印函数，输出一次可能性的所有环数
14.      * @param arr
15.      */
16.     private static void printlog(int[] arr) {
17.         if (arr!=null && arr.length>0) {
18.             for (int i = 0; i < arr.length; i++) {
19.                 System.out.print(arr[i]+"  ");
20.             }
21.             System.out.println("\n");
22.         }
23.     }
24.     
25.     /**
26.      * 计算一个一个数组中，所有元素的总和
27.      * @param scores
28.      * @return
29.      */
30.     private static int sumup(int[] scores) {
31.         int sum = 0;
32.         if(scores!=null && scores.length>0) {
33.             for(int i=0;i<scores.length;i++) {
34.                 sum += scores[i];
35.             }
36.         }
37.         return sum;
38.     }
39.     
40. //  /**
41. //   * 递归计算函数  try-1
42. //   * 
43. //   * @param personId 人数,从0开始计算
44. //   * @param currentScore  当前人打的环数，从0--10 
45. //   * @param scoreHistory  环数记录
46. //   */
47. //  private static void Caculate(int personId,int currentScore,
48. //          int[] scoreHistory) {
49. //      
50. //      //出口
51. //      if( 0 == personId) {//.最后一个人的时候，离90还剩下0-10环即可以满足一次
52. //          if(90-sumup(scoreHistory)> 0 && 90-sumup(scoreHistory)<10) {
53. //              currentScore = 90-sumup(scoreHistory);
54. //              scoreHistory[personId] = currentScore;
55. //              printlog(scoreHistory);
56. //          }
57. //      }else { //迭代
58. //          scoreHistory[personId] = currentScore;
59. //          //计算下一个人，下个人可能打出0--10环，因此需要循环
60. //          for(int i =0; i<=10;i++) {
61. //              Caculate(personId-1,i,scoreHistory);
62. //          }
63. //      }
64. //  }
66.     
67. //  /**
68. //   * 递归函数 try-2
69. //   * @param personId 人数,从0开始计算
70. //   * @param remanentScore 当前剩余环数 <=90
71. //   * @param scoreHistory 环数记录
72. //   */
73. //  private static void Caculate(int personId,int remanentScore
74. //          ,int[] scoreHistory) {
75. //      if(0 == personId) { //出口,最后一个人打出剩余环数就ok
76. //          if(remanentScore>=0 && remanentScore<=10) {
77. //              scoreHistory[personId] = remanentScore;
78. //              printlog(scoreHistory);
79. //              counter++;
80. //          }
81. //      }else {
82. //          for(int i=0; i<=10 ; i++) {//这个人可能打出0-10环
83. //              scoreHistory[personId] = i;
84. //              remanentScore -= i;
85. //              Caculate(personId-1,remanentScore,scoreHistory);
86. //          }
87. //      }
88. //  }
89.     
90.     /**
91.      * 递归函数  try-3 正确版
92.      * @param personId 人数,从0开始计算
93.      * @param remanentScore 当前剩余环数 <=90
94.      * @param scoreHistory 环数记录
95.      */
96.     private static void Caculate(int personId,int remanentScore
97.             ,int[] scoreHistory) {
98. //      if(remanentScore > (personId+1)*10) {
99. //          return;
100. //      }
101.         
102.         if(0 == personId) { //出口,最后一个人打出剩余环数就ok
103.             if(remanentScore>=0 && remanentScore<=10) {
104.                 scoreHistory[personId] = remanentScore;
105.                 printlog(scoreHistory);
106.                 counter++;
107.             }
108.         }else{
109.             for (int i = 0; i <= 10; i++) {//这个人可能打出0-10环
110.                 scoreHistory[personId] = i;
111.                 //              remanentScore-=i;
112.                 //              Caculate(personId-1,remanentScore,scoreHistory);
113.                 Caculate(personId - 1, remanentScore - i, scoreHistory);
114.             }
115.         }
116.     }
117.     
118.     
119.     public static void main(String[] args) {
120.         int[] store =  new int[10];
121.         long start = System.currentTimeMillis();
122.         Caculate(9,90,store);
123.         System.out.println(counter);
124.         long end = System.currentTimeMillis();
125.         
126.         long cost = end-start;
127.         System.out.println("用时：ms "+ cost);
128.     }
129. }