interview_preparation&backtrack_divided

1. subsets

import copy
class Solution:
    def subsets(self,nums):
        res=[[]]
        for n in nums:
            size=len(res)
            for i in range(size):
                res.append(copy.deepcopy(res[i]))
                res[-1].append(n)
        return res

nums=[1,2,3]
print(Solution().subsets(nums))

with same element

import copy
class Solution:
    def subsets(self,nums):
        res=[[]]
        for n in nums:
            size=len(res)
            for i in range(size):
                res.append(copy.deepcopy(res[i]))
                res[-1].append(n)
        return res

nums=[1,1,3]
res=Solution().subsets(nums)
res_=[tuple(tmp) for tmp in res]
res_=set(res_)
res=[list(tmp) for tmp in res_]
print(res)

bit op

___=000

__C=001

_B_=010

A__=100

_BC=011

AB_=110

A_C=101

ABC=111

1~2**n中哪些位为1，说明该位对应的元素在该子集中

'''bit op'''
class Solution:
    def subsets(self,nums):
        res=[]
        n=2**len(nums)

        for i in range(n):
            tmp=[]
            for j in range(len(nums)):
                if(i&(1<<j)):
                    tmp.append(nums[j])
            res.append(tmp)
            
        return res
            
nums=[1,2,3]
res=Solution().subsets(nums)
print(res)

3. combination sum + same ele in nums

class Solution:
    def dfs(self,nums,target,idx,path):
        if(sum(path)==target):
            self.res.append(path)
            return

        for i in range(idx,len(nums)):
            if i>idx and nums[i]==nums[idx]:
                continue

            self.dfs(nums,target,i+1,path+[nums[i]])
            

    def combSum(self,nums,target):
        if(len(nums)==0):
            return [[]]
        nums.sort()
        self.res=[]
        self.dfs(nums,target,0,[])

        return self.res

nums=[10,1,2,7,6,1,5]
print(Solution().combSum(nums,8))

4. generate valid parentheses

class Solution:
    def dfs(self,n,left,right,path):
        if(right==n):
            self.res.append(path)
            return
        
        if(left<n):
            self.dfs(n,left+1,right,path+"(")
        
        if(right<left):
            self.dfs(n,left,right+1,path+")")

    def generateParenthesis(self,n):
        if(n==0):
            return []
        self.res=[]
        
        self.dfs(n,0,0,"")

        return self.res

n=3
s=Solution()
res=s.generateParenthesis(n)
print(res)

5. reversed pair in nums

class Solution:
    def merge(self,nums,left,mid,right):
        i,j=left,mid+1
        new_nums=[]
        
        while(i<=mid and j<=right):
            if(nums[i]<=nums[j]):
                new_nums.append(nums[i])
                i+=1
            else:
                self.res+=mid-i+1
                new_nums.append(nums[j])
                j+=1

        while(i<=mid):
            new_nums.append(nums[i])
            i+=1
        
        while(j<=right):
            new_nums.append(nums[j])
            j+=1

        for i in range(len(new_nums)):
            nums[i+left]=new_nums[i]
        

    def mergeSort(self,nums,left,right):

        self.res=0      

        if(left<right):
            mid=left+(right-left)//2  
            print(nums[left:mid+1],nums[mid+1:right+1])
            self.mergeSort(nums,left,mid)
            self.mergeSort(nums,mid+1,right)

            self.merge(nums,left,mid,right)
        
        print(self.res)
        return nums



nums=[1,2,7,82,2,3,5,1]
# nums=[5,1]
print(Solution().mergeSort(nums,0,len(nums)-1))

6. permuation s witth no duplicated elements

class Solution(object):
    def permute(self, nums):
        res=[[]]
        for n in nums:
            res_tmp=[]
            for perm in res:
                for i in range(len(perm)+1):
                    # res_tmp.append(perm[:i]+[n]+perm[i:])
                    perm.insert(i,n)
                    res_tmp.append(perm[::-1])
                    perm.pop(i)         
            res=res_tmp
        return res