Leetcode 77. Combinations

recursion &dfs

recursion(slow)

class Solution:
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        res = []
        self.generate([],res,k,range(1,n+1))
        return res
    def generate(self,tmp,res,k,nums):
        if len(tmp)==k:
            tmp1=tmp.copy()
            res.append(tmp1)
            return
        else:
            for i in range(len(nums)):
                tmp.append(nums[i])
                self.generate(tmp,res,k,nums[i+1:])
                tmp.pop()

recursion with pruning

class Solution:
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        res = []
        self.generate(range(1, n + 1), k, res, [])
        return res

    def generate(self, array, k, res, temp):
        if k > len(array):
            return
        if k == 0:
            tmp1=temp.copy()
            res.append(tmp1)
        else:
            for i in range(len(array)):
                temp.append(array[i])
                self.generate(array[i + 1:], k - 1, res, temp)
                temp.pop()

dfs

class Solution:
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        if k == 1:
            return [[i] for i in range(1, n+1)]
        self.res = []
        self.dfs(n, k, 0, [])
        return self.res
    
    def dfs(self, n, k, start, path):
        if k == 0:  # k is the number of levels remaining
            self.res.append(path)
            return
        for i in range(start, n-k+1):
            self.dfs(n, k-1, i+1, path+[i+1])