Leetcode: Valid Sudoku @Python

class Solution:
    # @param board, a 9x9 2D array
    # @return a boolean
    def isValidSudoku(self, board):
        for i in range(9):
            dup=[]
            for j in range(9):
                if board[i][j]!='.':
                    if board[i][j] in dup:
                        return False
                    else:
                        dup.append(board[i][j])
        for j in range(9):
            dup=[]
            for i in range(9):
                if board[i][j]!='.':
                    if board[i][j] in dup:
                        return False
                    else:
                        dup.append(board[i][j])
        for i in [0,3,6]:
            for j in [0,3,6]:
                dup=[]
                for m in range(3):
                    for n in range(3):
                        if board[i+n][j+m]!='.':
                            if board[i+n][j+m] in dup:
                                return False
                            else:
                                dup.append(board[i+n][j+m])
        return True

Leetcode: Subsets @Python

class Solution:
    # @param S, a list of integer
    # @return a list of lists of integer
    def subsets(self, S):
        res = [[]]
        for e in sorted(S):
            res = res+[l+[e] for l in res]
        return res

Leetcode: Flatten Binary Tree to Linked List @Python

# Definition for a  binary tree node
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    # @param root, a tree node
    # @return nothing, do it in place
    def flatten(self, root):
        stack=[]
        crt=root
        while crt:
            if crt.right:
                stack.append(crt.right)
                crt.right=None
            if crt.left:
                crt.right=crt.left
                crt.left=None
                crt=crt.right
            else:
                if stack:
                    crt.right=stack.pop()
                    crt=crt.right
                else:
                    break

Leetcode: Longest Consecutive Sequence @Python

class Solution:
    # @param num, a list of integer
    # @return an integer
    def longestConsecutive(self, num):
        dict={x:False for x in num}
        maxlen=0
        for i in num:
            if dict[i]==False:
                dict[i]=True
                crt=i+1
                len1=0
                while crt in dict:
                    dict[crt]=True;crt+=1;len1+=1
                crt=i-1;len0=0
                while crt in dict:
                    dict[crt]=True;crt-=1;len0+=1
                maxlen=max(maxlen, 1+len0+len1)
        return maxlen

Leetcode: Valid Parentheses @Python

class Solution:
    # @return a boolean
    def isValid(self, s):
        n=len(s)
        stack=[]
        for i in range(n):
            if not stack:
                if s[i] in ['(','{','[']:
                    stack.append(s[i])
                else:
                    return False
            else:
                if (stack[-1]=='(' and s[i]==')') or (stack[-1]=="[" and s[i]=="]") or (stack[-1]=='{' and s[i]=='}'):
                    stack.pop()
                else:
                    stack.append(s[i])
        return not stack

Leetcode: Search in Rotated Sorted Array @Python

class Solution:
    # @param A, a list of integers
    # @param target, an integer to be searched
    # @return an integer
    def search(self, A, target):
        n=len(A)
        if n==0:
            return -1
        left=0
        right=n-1
        while left<=right:
            mid=(left+right)//2
            if left==right:
                return left if target==A[left] else -1
            elif target==A[mid]:
                return mid
            elif A[left]<=A[mid]:
                if A[left]<=target<A[mid]:
                    right=mid-1
                else:
                    left=mid+1
            else:
                if A[mid]<target<=A[right]:
                    left=mid+1
                else:
                    right=mid-1                
        return -1

Leetcode: Trapping Rain Water @Python

class Solution:
    # @param A, a list of integers
    # @return an integer
    def trap(self, A):
        expected = 0
        eindex = 0
        rain = 0
        block = 0
        for i in range(len(A)):
            if A[i] >= expected:
                rain += (i-eindex-1)*expected - block
                block = 0
                expected = A[i]
                eindex = i
            else:
                block += A[i]

        expected = eindex = block = 0
        for i in range(len(A)-1, -1, -1):
            if A[i] > expected:
                rain += (eindex-i-1)*expected - block
                block = 0
                expected = A[i]
                eindex = i
            else:
                block += A[i]
        return rain