【思路1-Java】回溯演算法|遞迴實現

本解法採用回溯演算法實現，回溯演算法的基本形式是“遞迴+迴圈”，正因為迴圈中巢狀著遞迴，遞迴中包含迴圈，這才使得回溯比一般的遞迴和單純的迴圈更難理解，其實我們熟悉了它的基本形式，就會覺得這樣的演算法難度也不是很大。原陣列中的每個元素有兩種狀態：存在和不存在。

① 外層迴圈逐一往中間集合 temp 中加入元素 nums[i]，使這個元素處於存在狀態

② 開始遞迴，遞迴中攜帶加入新元素的 temp，並且下一次迴圈的起始是 i 元素的下一個，因而遞迴中更新 i 值為 i + 1

③ 將這個從中間集合 temp 中移除，使該元素處於不存在狀態

public class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> temp = new ArrayList<Integer>();
        dfs(res, temp, nums, 0);
        return res;
    }
    private void dfs(List<List<Integer>> res, List<Integer> temp, int[] nums, int j) {
        res.add(new ArrayList<Integer>(temp));
        for(int i = j; i < nums.length; i++) {
            temp.add(nums[i]);  //① 加入 nums[i]
            dfs(res, temp, nums, i + 1);  //② 遞迴
            temp.remove(temp.size() - 1);  //③ 移除 nums[i]
        }
    }
}
 

【思路2-Java、Python】組合|非遞迴實現

這種方法是一種組合的方式

① 最外層迴圈逐一從 nums 陣列中取出每個元素 num

② 內層迴圈從原來的結果集中取出每個中間結果集，並向每個中間結果集中新增該 num 元素

③往每個中間結果集中加入 num

④將新的中間結果集加入結果集中

public class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        res.add(new ArrayList<Integer>());
        for (int num : nums) {  // ①從陣列中取出每個元素
            int size = res.size();
            for (int i = 0; i < size; i++) {
                List<Integer> temp = new ArrayList<>(res.get(i));  // ②逐一取出中間結果集
                temp.add(num);  // ③將 num 放入中間結果集
                res.add(temp);  // ④加入到結果集中
            }
        }
        return res;
    }
}
 

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res = [[]]
        for num in nums :
            for temp in res[:] :
                x = temp[:]
                x.append(num)
                res.append(x)
        return res