# Importing Libraries
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import seaborn as sns

# Dataprep for exploratory data analysis
from dataprep.eda import create_report
from dataprep.eda import plot, plot_correlation, plot_missing

# mport Regressor Metric Graph Plot - for ML analysis
from regressormetricgraphplot import *

# Set style to 'seaborn / Plot inline
plt.style.use('seaborn')
%matplotlib inline
%config InlineBackend.figure_format = 'retina'


# Load Dataframe
df = pd.read_csv('path/to/file.csv')
df.head()

df.isna().sum()
df.drop_duplicates(inplace = True)
df.info()
df.describe()

# Generate Dataprep Report
report = create_report(df, title='My Report')
create_report()

plot(df, col1, col2)

# df sortby
df.sort_values(by=[col1, col2], ascending=[True, True])

# df groupby
df.groupby(col).mean()

def combinationSum2(candidates, target):
    res = []
    candidates.sort()
    
    def dfs(target, index, path):
        if target < 0:
            return  # backtracking
        if target == 0:
            res.append(path)
            return  # backtracking 
        for i in range(index, len(candidates)):
            if candidates[i] == candidates[i-1]:
                continue
            dfs(target-candidates[i], i+1, path+[candidates[i]])
            
    dfs(target, 0, [])
    return res

def combinationSum2(candidates, target):
    res = []
    candidates.sort()
    
    def dfs(target, index, path):
        if target < 0:
            return  # backtracking
        if target == 0:
            res.append(path)
            return 
        for i in range(index, len(candidates)):
            dfs(target-candidates[i], i, path+[candidates[i]])
            
    dfs(target, 0, [])
    return res

def subsetsWithDup(nums):
    res = []
    nums.sort()
    
    
    def dfs(index, path):
        res.append(path)
        for i in range(index, len(nums)):
            if i > index and nums[i] == nums[i-1]:
                continue
            dfs(i+1, path+[nums[i]])
            
    dfs(0, [])
    return res

def subsets1(nums):
    res = []
    nums.sort()
    
    def dfs(index, path):
        res.append(path)
        for i in range(index, len(nums)):
            dfs(i+1, path+[nums[i]])
            
    dfs(0, [])
    return res

# nums = list

def permuteUnique(self, nums):
    res, visited = [], [False]*len(nums)
    nums.sort()
    self.dfs(nums, visited, [], res)
    return res
    
def dfs(self, nums, visited, path, res):
    if len(nums) == len(path):
        res.append(path)
        return 
    for i in xrange(len(nums)):
        if not visited[i]: 
            if i>0 and not visited[i-1] and nums[i] == nums[i-1]:  # here should pay attention
                continue
            visited[i] = True
            self.dfs(nums, visited, path+[nums[i]], res)
            visited[i] = False

# nums = list

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        res = []
        self.dfs(nums, [], res)
        return res

    def dfs(self, nums, path, res):
        if not nums:
            res.append(path)
            #return # backtracking
        for i in range(len(nums)):
            self.dfs(nums[:i]+nums[i+1:], path+[nums[i]], res)

def combine(self, n: int, k: int) -> List[List[int]]:
        res = []
        nums = range(1,n+1);

        def dfs(k, index, path):
            if k == 0:
                res.append(path)
                return # backtracking 
            for i in range(index, len(nums)):
                dfs(k-1, i+1, path+[nums[i]])
               
        dfs(k, 0 ,[])
        return res