从数列1, 2, 3, ... , n 中 随意取几个数,使其和等于sum.

blog原址:http://blog.csdn.net/beiyeqingteng/article/details/7107636

问题：

输入两个整数 n 和 sum，从数列1, 2, 3, ... , n 中 随意取几个数,使其和等于 sum,要求将其中所有的可能组合列出来.

比如n = 5, sum  = 8, 那么所有的组合为：

3  5 或者 1  5  2 或者 1  4  3

思路：

对于一个给定的总和sum, 如果我们从数列的尾部开始，即从n开始，sum 要么等于 n 加上 剩余的1到 n - 1之间的某一个组合，或者 等于 1 到 n-1 之间的某一个组合。

递归的方程为：

findSum(sum, n) = n + findSum(sum - n, n -1) 或者 findSum (sum, n) = findSum (sum - n, n -1)

view plain

1. public class FindSum {  
2.     private static Stack<Integer> stack = new Stack<Integer>();  
3.     public static void findSum(int sum, int n) {  
4.         //找不到满足条件的情况  
5.         if ( sum <= 0 || n <= 0) return;  
6.         //sum 大于 n， 需要再次递归  
7.         if (sum > n) {  
8.             stack.push(n); //取 n  
9.             findSum(sum - n, n - 1);// n加入，取 n = n-1, sum = sum-n  
10.             stack.pop(); // 不取 n  
11.             findSum(sum, n - 1);    // n没有加入，取n = n-1,sum = sum  
12.         } else {  
13.             System.out.print(sum);  //  sum <= n ,直接输出n就可以满足了  
14.             for (int i = 0; i < stack.size(); i ++)  
15.                 System.out.print(" "+ stack.get(i));  
16.             System.out.println();     
17.               
18.             //上面部分得到的是一种情况，但是还存在另一种情况，我们需要找出从 1 到 sum - 1 里面是否存在值，它们的和等于sum  
19.             if (sum != 1) {  
20.                 findSum(sum, sum - 1);  
21.             }  
22.         }  
23.     }  
24.     public static void main(String[] args) {  
25.         int sum = 8;  
26.         int n = 5;  
27.         findSum(sum,n);  
28.     }  
29. }  

扩展1：

如果在上面这道题里再加上一个条件：所有组合里数的个数是一定的。下面代码中用number 来表示所有组合数的个数。

view plain

1. public class FindSum {  
2.     private static Stack<Integer> stack = new Stack<Integer>();  
3.     public static void findSum(int sum, int n, int number) {  
4.         //找不到满足条件的情况  
5.         if ( sum <= 0 || n <= 0 || number <= 0 || n < number) return;  
6.         //sum 大于 n， 需要再次递归  
7.         if (sum > n ) {  
8.             stack.push(n); //取 n  
9.             findSum(sum - n, n - 1, number - 1);// n加入，取 n = n-1, sum = sum-n  
10.             stack.pop(); // 不取 n  
11.             findSum(sum, n - 1, number);    // n没有加入，取n = n-1,sum = sum  
12.         } else if (number == 1) {  
13.             System.out.print(sum);  //  sum <= n ,直接输出n就可以满足了  
14.             for (int i = 0; i < stack.size(); i ++)  
15.                 System.out.print(" "+ stack.get(i));  
16.             System.out.println();     
17.         } else {  
18.             findSum(sum, sum -1, number);  
19.         }  
20.     }  
21.     public static void main(String[] args) {  
22.         int sum = 10;  
23.         int n = 12;  
24.         int number = 4;  
25.         findSum(sum,n, number);  
26.     }  
27. }  

扩展2：任意给定一个不含有重复值的数组，找出和为 sum 的所有的组合，但是，组合中个数为 number.

比如：数组为 {5， 2， 1， 7， 3}， sum = 8, number = 3， 那么，就只能输出 5， 2，1。

原理是一样的，代码如下：

view plain

1. public class FindSum {  
2.     public static int[] array = {5, 2, 1, 7, 3, 4, 6, 9};  
3.     private static Stack<Integer> stack = new Stack<Integer>();  
4.     public static void findSum(int sum, int n, int number) {  
5.           
6.         if (number == 0 && sum == 0) {  
7.             for (int i = 0; i < stack.size(); i ++) {  
8.                 System.out.print(" "+ stack.get(i));  
9.             }  
10.             System.out.println();     
11.             return;  
12.         }  
13.           
14.         if (sum < 0 || n < 0 || n < number - 1) return;  
15.           
16.         stack.push(array[n]); //取 n  
17.         findSum(sum - array[n], n - 1, number - 1);// n加入，取 n = n-1, sum = sum-n  
18.         stack.pop(); // 不取 n  
19.         findSum(sum, n - 1, number);    // n没有加入，取n = n-1,sum = sum  
20.     }  
21.     public static void main(String[] args) {  
22.         int sum = 10;  
23.         int number = 4;  
24.         findSum(sum, array.length - 1, number);  
25.     }  
26. }  

扩展3：

如果数组里面有重复的数，怎么把相应的组合找出来。找出来的组合里不存在重复的情况。

这里我们需要把数组排序，那么取下一个的时候，我们需要判断前一个值是否已经取过了，因为如果取过了再取的话，就一定会重复，因为最头的一个重复值已经考虑了所有的情况。

view plain

1. public class FindSum {  
2.     public static int[] array = {9, 7, 6, 5, 4, 3, 2, 1, 1};  
3.     private static Stack<Integer> stack = new Stack<Integer>();  
4.     public static void findSum(int sum, int n, int number) {  
5.               
6.         if (number == 0 && sum == 0) {  
7.             for (int i = 0; i < stack.size(); i ++) {  
8.                 System.out.print(" "+ stack.get(i));  
9.             }  
10.             System.out.println();     
11.             return;  
12.         }  
13.           
14.         if (sum < 0 || n < 0 || n < number - 1) return;  
15.           
16.         stack.push(array[n]); //取 n  
17.         findSum(sum - array[n], n - 1, number - 1);// n加入，取 n = n-1, sum = sum-n  
18.         stack.pop(); // 不取 n  
19.         //如果下一个值重复了，就不再执行findSum(sum, n - 1, number)这条语句。  
20.         if (n < array.length - 1 && array[n] == array[n + 1] ) return;  
21.         findSum(sum, n - 1, number);    // n没有加入，取n = n-1,sum = sum  
22.           
23.     }  
24.     public static void main(String[] args) {  
25.         int sum = 10;  
26.         int number = 4;  
27.         findSum(sum, array.length - 1, number);  
28.     }  
29. }