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

问题：

输入两个整数 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 -1)

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

扩展1：

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

public class FindSum {
	private static Stack<Integer> stack = new Stack<Integer>();
	public static void findSum(int sum, int n, int number) {
		//找不到满足条件的情况
		if ( sum <= 0 || n <= 0 || number <= 0 || n < number) return;
		//sum 大于 n， 需要再次递归
		if (sum > n ) {
			stack.push(n); //取 n
			findSum(sum - n, n - 1, number - 1);// n加入，取 n = n-1, sum = sum-n
			stack.pop(); // 不取 n
			findSum(sum, n - 1, number);    // n没有加入，取n = n-1,sum = sum
		} else if (number == 1) {
			System.out.print(sum);  //  sum <= n ,直接输出n就可以满足了
			for (int i = 0; i < stack.size(); i ++)
				System.out.print(" "+ stack.get(i));
			System.out.println();	
		} else {
			findSum(sum, sum -1, number);
		}
	}
	public static void main(String[] args) {
		int sum = 10;
		int n = 12;
		int number = 4;
		findSum(sum,n, number);
	}
}

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

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

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

public class FindSum {
	public static int[] array = {5, 2, 1, 7, 3, 4, 6, 9};
	private static Stack<Integer> stack = new Stack<Integer>();
	public static void findSum(int sum, int n, int number) {
		
		if (number == 0 && sum == 0) {
			for (int i = 0; i < stack.size(); i ++) {
				System.out.print(" "+ stack.get(i));
			}
			System.out.println();	
			return;
		}
		
		if (sum <= 0 || n < 0 || number <= 0 || n < number - 1) return;
		
		stack.push(array[n]); //取 n
		findSum(sum - array[n], n - 1, number - 1);// n加入，取 n = n-1, sum = sum-n
		stack.pop(); // 不取 n
		findSum(sum, n - 1, number);    // n没有加入，取n = n-1,sum = sum
	}
	public static void main(String[] args) {
		int sum = 10;
		int number = 4;
		findSum(sum, array.length - 1, number);
	}
}

扩展3：

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

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

public class FindSum {
	public static int[] array = {5, 5, 5,5,3,3,3, 2,2,2, 1,1,1,1};
	private static Stack<Integer> stack = new Stack<Integer>();
	public static void findSum(int sum, int n, int number) {
		if (number == 0 && sum == 0) {
			for (int i = 0; i < stack.size(); i ++) {
				System.out.print(" "+ stack.get(i));
			}
			System.out.println();	
			return;
		}
		if (sum <= 0 || n < 0 || number <= 0 || n < number - 1) return;
		stack.push(array[n]); //取 n
		findSum(sum - array[n], n - 1, number - 1);// n加入，取 n = n-1, sum = sum-n
		stack.pop(); // 不取 n
		//如果下一个值重复了，就要找到与pop出来的那个值不同的第一个。
		if (n > 0 && array[n - 1] == array[n] ) {
			while ((n - 1) >= 0 && array[n - 1] == array[n]) {
				n--;
			}
		} else {
			findSum(sum, n - 1, number);    // n没有加入，取n = n-1,sum = sum
		}
	}

	public static void main(String[] args) {
		int sum = 18;
		int number = 6;
		findSum(sum, array.length - 1, number);
	}
}

参考： http://blog.csdn.net/randyjiawenjie/article/details/6335208#comments