leetcode刷题

class Solution(object):
    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        length=len(matrix)
        ans=[]
        for i in range(length):
            row=[]
            for j in range(length):
                row.append(matrix[length-j-1][i])
            ans.append(row)
        matrix[:]=ans
        return matrix

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def removeDuplicateNodes(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head:
            return head
        history = set()
        # history = []
        temp = head
        while temp:
            if temp.val not in history:
                # history.append(temp.val)
                history.add(temp.val)
                pre = temp
                temp = temp.next
            else:
                pre.next = temp.next
                temp = temp.next

        return head

class Solution(object):
    def kthToLast(self, head, k):
        """
        :type head: ListNode
        :type k: int
        :rtype: int
        """
        cur = head
        n = 0
        while cur.next:
            n += 1
            cur = cur.next
        c,cur2 = 0,head
        while c <= n-k:
            c += 1
            cur2 = cur2.next
        return cur2.val

# 递归算法
class Solution:
    def move(self, path, now, grid, r, c):                  # 传入递归变量path(保存正确路径)，现在的位置，整个地图，以及地图大小(重复传入避免重复计算)
        print(now)
        if now==[r-1, c-1]:                                     # 递归终止条件: 现在在终点
            path.insert(0, now)                                     # 把当前位置(终点)插入正确路径的首位(因为它是第一个完成的所以插在首位，后面的位置都插在他前面)
            return True, now
        else:                                                   # 递归: 若不在终点
            if now[1]<=c-2 and grid[now[0]][now[1]+1]==0:           # 若当前位置的右边可行进(注意与可完成的区别)，则
                next_op = [now[0], now[1]+1]                            # 下一步向右
                now_way = self.move(path, next_op, grid, r, c)          # 接受向右的结果
                if now_way[0]:                                              # 向右可到达(则当前位置可到达)
                    path.insert(0, now)                                     # 把当前位置插在历史记录的可到达路径的首位
                    return True, path
                elif now[0]<=r-2 and grid[now[0]+1][now[1]]==0:     # 若右方不可行进
                    next_op = [now[0]+1, now[1]]                        # 则尝试下方
                    now_way = self.move(path, next_op, grid, r, c)      # 接受向下的结果
                    if now_way[0]:                                          # 向下可到达(则当前位置可到达)
                        path.insert(0, now)                                 # 把当前位置插在历史记录的可到达路径的首位
                        return True, path
                    else:                                           # 若右方与下方均不可到达
                        return False,                                   # 则当前位置不可到达终点
                else:
                    return False, 
            elif now[0]<=r-2 and grid[now[0]+1][now[1]]==0:         # 若右方不可行进(如有障碍物或者到地图边缘)
                next_op = [now[0]+1, now[1]]                            # 下一步向下
                now_way = self.move(path, next_op, grid, r, c)
                if now_way[0]:
                    path.insert(0, now)
                    return True, path
                else:
                    return False, 
            else:                                                   # 若右方与下方均不可行进
                return False,                                           # 则当前位置不可到达

    def pathWithObstacles(self, obstacleGrid: List[List[int]]) -> List[List[int]]:
        r = len(obstacleGrid)
        c = len(obstacleGrid[0]) # 记录下地图的大小
        if r==1 and c==1:   # 如果是1x1直接返回结果
            if obstacleGrid[0][0]==0:
                return [[0, 0]]
            else:
                return []
        if obstacleGrid[0][0]==1 or obstacleGrid[r-1][c-1]==1: # 如果起点或者终点有障碍物则判否
            return []
        way = self.move([], [0, 0], obstacleGrid, r, c) # 递归运算，返回值是元组，way[0]表示是否存在路径，way[1]给出路径
        print(way)
        if way[0]:
            return way[1]
        else:
            return []

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

class Solution(object):
    def pathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: int
        """
        self.ans = 0
        def f(node, vals):
            if node:
                vs = [i + node.val for i in vals] + [node.val]
                for i in range(len(vs)):
                    if vs[i] == sum:
                        self.ans += 1
                f(node.left, vs)
                f(node.right, vs)
        f(root, [])
        return self.ans

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        re = []
        state = ‘‘
        def dsp(state, p, q):       #p,q分别表示(和)还剩的个数，有个隐含条件：就是(在组合时候比)用的多或相等
            if p > q:               #非法，剪枝
                return 
            if q == 0:              #)用完之时
                re.append(state)
            
            if p > 0:
                dsp(state+‘(‘, p-1, q)
            if q > 0:
                dsp(state+‘)‘, p, q-1)

        dsp(state, n, n)
        return re