继续继续 114 -118自己完成的一周

114  二叉树展开为链表  ： 

反先序遍历    我真是天才

如果是前序遍历的话，根结点没法加入结果，因为这样 本来树的结构和结果会缠绕到一起。

所以想着能不能先加入叶子结点。
就想到了反先序 右 左 根 这样的顺序 这样 第一个访问到的就是最右下角那个结点 把他加入结果即可。
这样结果就是从下往上构建的了 比如题中就是先建6
然后把6变成5的右子树
再把5变成4的右子树 以此类推

而且 访问到一个结点时 他的孩子都被处理过了 可以放心的把他加入结果
空间复杂度打败9成9的人

class Solution:
    def flatten(self, root: TreeNode) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        def antipre(root):
            nonlocal p
            if root.right:      #看左
                antipre(root.right)
            if root.left:    #看右
                antipre(root.left)
            root.left = None      #左节点置空 右结点接到结果树上
            root.right = p
            p = root
        if not root :
            return None
        p = None
        antipre(root)
        return root

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/solution/fan-xian-xu-bian-li-wo-zhen-shi-tian-cai-3rqq/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

115  不同的子序列  

困难的动态规划 我自己想的！！！！！！！

转移方程看不出来 是写出来的 试着填了一下表格 发现真的是这样
对于每个格子 如果s，t对应位置不等 就填0
如果相等 就填所在列的最大值 加上前一列的最大值
如果是第一列 就是第一列最大值加1
所以每次更新后也要更新最大值
但是注意要算完一行后才能更新。

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        row = len(s)
        col = len(t)
        dp = [[0]*col for i in range(row)]
        maxnum = [0]*col
        maxnum2 = [0] *col
        def updatemax(currow):
            for index,each in enumerate(currow):
                if each > maxnum[index]:
                    maxnum[index] = each
        for i in range(row):
            for j in range(col):
                if s[i] == t[j]:
                    if j == 0:
                        dp[i][j] = maxnum[0]+ 1

                    else:
                        dp[i][j] = maxnum[j] + maxnum[j-1]
                    maxnum2[j] = dp[i][j]
                else:
                    dp[i][j] = 0
            maxnum = maxnum2[:]
        return maxnum[col-1]


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/distinct-subsequences/solution/a-ha-ha-ha-ha-ha-ha-ha-di-yi-ci-zi-ji-du-ohxj/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

或者再优化 

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        row = len(s)
        col = len(t)
        maxnum = [0]*col
        maxnum2 = [0] *col
        for i in range(row):
            for j in range(col):
                if s[i] == t[j]:
                    if j == 0:
                        maxnum2[0] = maxnum[0]+ 1
                    else:
                        maxnum2[j] = maxnum[j] + maxnum[j-1]
            maxnum = maxnum2[:]
        return maxnum[col-1]

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/distinct-subsequences/solution/kan-liao-kan-ti-jie-you-ti-xing-liao-wo-rs9yw/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

116 填充每一个节点的下一个右侧节点指针 。

　　
时间击败99.5的人 空间被95的人击败

我们从每一行的最左边那个结点开始 看他的左右子树
他的左子树的next指向右子树 如果他有next 那么他的右子树指向他的next的左子树
然后对他的next也采取这样的办法 这样 root的下一行就完成了
再让root指向下一行最左边 执行同样步骤
没有额外空间啊 除了递归

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        def levelcon(root):
            root.left.next = root.right
            if root.next:
                root.right.next = root.next.left
                levelcon(root.next)
        if not root:
            return root
        p = root
        while p.left!= None:
            levelcon(p)
            p = p.left
        return root

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/solution/shi-jian-ji-bai-995de-ren-kong-jian-bei-3bcsw/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

117 右侧结点2 

对于每一个最左边的结点 连接他的左右结点和他的NEXT的结点

对于一棵树 找到每一行最左边的结点 对他进行连接

 

class Solution:
    def connect(self, root: 'Node') -> 'Node':
        def connectlev(root):
            if root.left:
                if root.right:
                    root.left.next = root.right
                    if  root.next:
                        root.right.next = connectlev(root.next)
                elif root.next:
                    root.left.next = connectlev(root.next)
                return root.left
            elif root.right:
                if  root.next:
                    root.right.next = connectlev(root.next)
                return root.right
            elif root.next:
                return connectlev(root.next)
            else:
                return None
        def findnextleft(root):
            if root.left or root.right:
                connectlev(root)
                if root.left :
                    findnextleft(root.left)
                else:
                    findnextleft(root.right)
            elif root.next:
                findnextleft(root.next)
        if root == None:
            return None
        findnextleft(root)
        return root

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/solution/wo-du-wu-yu-liao-xiang-shi-zai-bao-li-po-g2wb/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 118 杨辉三角 

把1,2提出来 感觉很好

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        if numRows == 1:
            return [[1]]
        if numRows == 2:
            return [[1],[1,1]]
        rel = [[1],[1,1]]
        for i in range(numRows-2):
            currel = [1]
            for index,_ in enumerate(rel[-1][:-1]):
                currel.append(rel[-1][index]+ rel[-1][index+1])
            currel.append(1)
            rel.append(currel[:])
        return rel

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/pascals-triangle/solution/wang-shi-wu-xu-ti-zai-hui-tou-you-shi-ji-wea9/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。