leetcode未整理合集

78

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        length=len(nums)
        if length==0:
            return [[]]
        n=nums.pop(-1)
        ret=self.subsets(nums)
        length=len(ret)
        for i in range(length):
            ret.append(ret[i][:])
            ret[-1].append(n)
        return ret
        

class Solution(object):
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        ret=[]
        track=[]
        self.backtrack(track,0,nums,ret)
        return ret
    
    def backtrack(self,track,st,nums,ret):
        ret.append(track[:])
        for i in range(st,len(nums)):
            track.append(nums[i])
            self.backtrack(track,i+1,nums,ret)
            track.pop(-1)

77

https://leetcode-cn.com/problems/subsets/

class Solution(object):
    def combine(self, n, k):
        """
        :type n: int
        :type k: int
        :rtype: List[List[int]]
        """
        ret=[]
        track=[]
        if(n<=0 or k<=0):
            return ret
        self.backtrack(1,n,k,track,ret)
        return ret

    def backtrack(self,start,n,k,track,ret):
        if(len(track)==k):
            ret.append(track[:])
        if(len(track)>k or start>n):
            return
        
        for i in range(start,n+1):
            track.append(i)
            #print('start:',start,'  i:',i)   
            #print('track:',track)
            self.backtrack(i+1,n,k,track,ret)
            track.pop(-1)

https://leetcode-cn.com/problems/combinations/

46

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        ret=[]
        track=[]
        self.backtrack(nums,track,ret)
        return ret
    
    def backtrack(self,nums,track,ret):
        if(len(track)==len(nums)):
            ret.append(track[:])
            return
        
        for i in range(len(nums)):
            if(len(nums)==len(track)):
                ret.append(track[:])
            if(nums[i] in track):
                pass
            else:
                track.append(nums[i])
                self.backtrack(nums,track,ret)
                track.pop(-1)

https://leetcode-cn.com/problems/permutations/

https://mp.weixin.qq.com/s/qT6WgR6Qwn7ayZkI3AineA

51

class Solution(object):
    def solveNQueens(self, n):
        """
        :type n: int
        :rtype: List[List[str]]
        """
        ret=[]
        track=[]
        self.backtrack(1,ret,track,n)
        return ret
        
    def backtrack(self,start,ret,track,n):
        if(len(track)==n):
            ret.append(track[:])
            return
        
            
        for row in range(start,n+1):
            for column in range(1,n+1):
                if(len(track)==row-1):
                    t=['.' for i in range(n)]
                    t[column-1]='Q'
                    tmp=''.join(t)
                    if(self.conflict(row,column,track,n)):
                        continue
                    else:
                        track.append(tmp)
                        self.backtrack(row+1,ret,track,n)
                        track.pop(-1)

    def conflict(self,row,column,track,n):
        #print('row:',row)
        #print('column:',column)
        #print('track',track)
        if(row==1):
            return False
        for i in range(1,row):
            if(track[row-1-i][column-1]=='Q'):
                return True
            if(column>=1+i):
                if(track[row-1-i][column-1-i]=='Q'):
                    return True
            if(column<n+1-i):
                if(track[row-1-i][column-1+i]=='Q'):
                    return True
        return False

https://leetcode-cn.com/problems/n-queens/

https://mp.weixin.qq.com/s?__biz=MzAxODQxMDM0Mw==&mid=2247484709&idx=1&sn=1c24a5c41a5a255000532e83f38f2ce4&chksm=9bd7fb2daca0723be888b30345e2c5e64649fc31a00b05c27a0843f349e2dd9363338d0dac61&scene=178&cur_album_id=1318883740306948097#rd

36

class Solution(object):
    def isValidSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: bool
        """
        
        for i in range(9):
            for j in range(9):
                if(board[i][j]=='.'):
                    continue
                if(self.isValid(board,i,j)==False):
                    return False
        return True

    def isValid(self,board,row,column):
        for i in range(9):
            if(i!=column and board[row][i]==board[row][column]):
                return False
            if(i!=row and board[i][column]==board[row][column]):
                return False
            if(((row/3)*3+i/3)!=row and ((column/3)*3+i%3)!=column and board[(row/3)*3+i/3][(column/3)*3+i%3]==board[row][column]):
                return False
        return True
     

https://leetcode-cn.com/problems/valid-sudoku/

37

class Solution(object):
    def solveSudoku(self, board):
        """
        :type board: List[List[str]]
        :rtype: None Do not return anything, modify board in-place instead.
        """
        self.backtrack(board,0,0)
        
    def backtrack(self,board,row,column):
        if(column==9):
            return self.backtrack(board,row+1,0)
        if(row==9):
            return True

        for i in range(row,9):
            for j in range(column,9):
                if(board[i][j]!='.'):
                    return self.backtrack(board,i,j+1)
                for n in range(1,10):
                    #print('n:',n)
                    if(not(self.isValid(board,i,j,n))):
                        #print('i:',i,' j:',j,' n:',n)
                        continue
                    board[i][j]=str(n)
                    #print('j:',j,'  n:',n,'  board:',board[0])
                    if(self.backtrack(board,i,j+1)):
                        return True
                    board[i][j]='.'
                return False
        return False

  
    def isValid(self,board,row,column,n):
        #print('row:',row,' column:',column)
        for i in range(9):
            #print('i:',i)
            if(board[row][i]!='.' and int(board[row][i])==n):
                #print('here1')
                return False
            if(board[i][column]!='.' and int(board[i][column])==n):
                #print('here2')
                return False
            if(board[(row//3)*3+i//3][(column//3)*3+i%3]!='.' and int(board[(row//3)*3+i//3][(column//3)*3+i%3])==n):
                #print((row//3)+i//3)
                #print((column//3)+i%3)
                #print('here3')
                return False
        return True       

https://mp.weixin.qq.com/s?__biz=MzAxODQxMDM0Mw==&mid=2247485097&idx=1&sn=a5e82da8646cd8985de6b2b0950de4e2&chksm=9bd7f8a1aca071b7b72e23013bc2a7c528ee913fded9278e2058bc98d7c746e439737d7abb5b&scene=178&cur_album_id=1318883740306948097#rd

22

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        ret=[]
        track=[]
        self.backtrack(n,n,ret,track)
        return ret

    def backtrack(self,left,right,ret,track):
        if(left>right):
            return
        if(left<0 or right<0):
            return
        if(left==0 and right==0):
            ret.append(''.join(track))
        
        track.append('(')
        self.backtrack(left-1,right,ret,track)
        track.pop(-1)

        track.append(')')
        self.backtrack(left,right-1,ret,track)
        track.pop(-1)

https://mp.weixin.qq.com/s?__biz=MzAxODQxMDM0Mw==&mid=2247485115&idx=1&sn=dd64bfedb1da22f308228a0933583adf&chksm=9bd7f8b3aca071a5b96e7cb9464c01c045997d36d677b14163b6b009df2aa9b1b613ace3bc5a&scene=178&cur_album_id=1318883740306948097#rd