leecode 216. 组合总和 III

​​​​​​216. 组合总和 III

        本题是力扣77.组合的升级版，原来是要求求出所有符合条件k和n的集合，本题要在上一题的基础上求出集合的和，符合条件的输出为集合，因此可以回溯算法。

//普通回溯+递归：

class Solution {

    List<List<Integer>> res = new ArrayList<>();
	LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backTracking(n, k, 1, 0);
		return res;
    }
//n、k、startIndex、sum分别代表需求集合总和、集合包含的数字数量、开始循环的索引、当前集合总和
    private void backTracking(int n, int k, int startIndex, int sum) {
//当path中包含的数字和k相同时，说明循环到底需要判断是否符合条件
         if (path.size() == k) {
//如果当前集合总和sum等于需求集合总和n，符合条件，放入res集合，否则结束循环返回上层
            if (sum == n) {
                res.add(new ArrayList<>(path));
            }
            return;
        }
//从当前索引开始遍历，由于本题集合已经固定为[1,...,9]，所以结束条件为9
        for (int i = startIndex; i <=9; i ++) {
//记录当前总和
            sum += i;
//加入当前数到path集合
            path.add(i);
//循环索引位置+1，从此位置继续递归
            backTracking(n, k, i + 1, sum);
//回溯，有递归就要有回溯，删除当前最新加入的元素
            path.removeLast();
//同样，当前总和也要减去当前元素
            sum -= i;
        }
       
    }
}


//剪枝递归：

class Solution {
	List<List<Integer>> result = new ArrayList<>();
	LinkedList<Integer> path = new LinkedList<>();

	public List<List<Integer>> combinationSum3(int k, int n) {
		backTracking(n, k, 1, 0);
		return result;
	}

	private void backTracking(int targetSum, int k, int startIndex, int sum) {
		// 减枝
    //据图可以看出，如果当前总和大于目标总和，那么后面的所有循环一定都大于总和，直接返回结束循环
		if (sum > targetSum) {
			return;
		}

		if (path.size() == k) {
			if (sum == targetSum) result.add(new ArrayList<>(path));
			return;
		}
		
		// 减枝 9 - (k - path.size()) + 1
//这里同77题的剪枝
		for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
			path.add(i);
			sum += i;
			backTracking(targetSum, k, i + 1, sum);
			//回溯
			path.removeLast();
			//回溯
			sum -= i;
		}
	}
}



//最终版本回溯
//这个版本不需要参数sum，直接修改n，结束条件判断n是否为0
class Solution {

    List<List<Integer>> res = new ArrayList<>();
	LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combinationSum3(int k, int n) {
        backTracking(n, k, 1);
		return res;
    }

    private void backTracking(int n, int k, int startIndex) {
        if (n < 0) return;
        if (path.size() == k) {
            if (n == 0) {
                res.add(new ArrayList<>(path));
            }
            return;
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i ++) {
            //这一步刚开始没意识到怎么错了，但是确实错了，应该在递归中直接减去i
            //n -= i;
            path.add(i);
            backTracking(n - i, k, i + 1);
            path.removeLast();
            
        }
        
    }
}