从零开始的力扣刷题记录-第三十八天

1137. 第 N 个泰波那契数-简单

题目描述：
泰波那契序列 Tn 定义如下：
T0 = 0, T1 = 1, T2 = 1, 且在 n >= 0 的条件下 Tn+3 = Tn + Tn+1 + Tn+2
给你整数 n，请返回第 n 个泰波那契数 Tn 的值。

题解：
动态规划，用三个变量保存中间值可以节省数组的开销

代码（Go）：

func tribonacci(n int) int {
    if n == 0{
        return 0
    }
    if n == 1 || n == 2{
        return 1
    }
    p0,p1,p2 := 0,1,1
    for i := 3;i <= n;i++{
        temp := p0 + p1 + p2
        p0 = p1
        p1 = p2
        p2 = temp
    }
    return p2
}

993. 二叉树的堂兄弟节点-简单

题目描述：
在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。
如果二叉树的两个节点深度相同，但 父节点不同 ，则它们是一对堂兄弟节点。
我们给出了具有唯一值的二叉树的根节点 root ，以及树中两个不同节点的值 x 和 y 。
只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true 。否则，返回 false。

题解：
用了两次递归，一次判断是否是兄弟节点，一次判断二者是否位于同一高度

代码（Go）：

func isCousins(root *TreeNode, x int, y int) bool {
    if isBrother(root,x,y){
        return false
    }
    return height(root, x, 0) == height(root, y, 0)
}

func isBrother(root *TreeNode,x int,y int) bool {
    if root.Left != nil && root.Right != nil{
        if root.Left.Val == x && root.Right.Val == y{
            return true
        }
        if root.Right.Val == x && root.Left.Val == y{
            return true
        }
        return isBrother(root.Left, x, y) || isBrother(root.Right, x, y)
    }
    if root.Left != nil{
        return isBrother(root.Left, x, y)
    }
    if root.Right != nil{
        return isBrother(root.Right, x, y)
    }
    return false
}

func height(root *TreeNode,x int,h int) int {
    if root == nil{
        return 0
    }
    if root.Val == x{
        return h
    }
    return height(root.Left,x,h + 1) | height(root.Right,x,h + 1)
}

559. N 叉树的最大深度-简单

题目描述：
给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

题解：
深度搜索递归，和二叉树思路一样，只不过把遍历两个子节点变成了for循环遍历子节点数组

代码（Go）：

func maxDepth(root *Node) int {
    if root == nil{
        return 0
    }
    return height(root,1)
}

func height(root *Node,h int) int {
    re := h
    for _,v := range root.Children{
        temp := height(v, h + 1)
        if temp > re{
            re = temp
        }
    }
    return re
}

165. 比较版本号-中等

题目描述：
给你两个版本号 version1 和 version2 ，请你比较它们。
版本号由一个或多个修订号组成，各修订号由一个 ‘.’ 连接。每个修订号由 多位数字 组成，可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号，下标从 0 开始，最左边的修订号下标为 0 ，下一个修订号下标为 1 ，以此类推。例如，2.5.33 和 0.1 都是有效的版本号。
比较版本号时，请按从左到右的顺序依次比较它们的修订号。比较修订号时，只需比较 忽略任何前导零后的整数值 。也就是说，修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号，则该修订号视为 0 。例如，版本 1.0 小于版本 1.1 ，因为它们下标为 0 的修订号相同，而下标为 1 的修订号分别为 0 和 1 ，0 < 1 。
返回规则如下：
如果 version1 > version2 返回 1，
如果 version1 < version2 返回 -1，
除此之外返回 0。

题解：
分割后比较每一段的版本号即可

代码（Go）：

func compareVersion(version1 string, version2 string) int {
    v1 := strings.Split(version1,".")
    v2 := strings.Split(version2,".")
    i := 0
    for i < len(v1) && i < len(v2){
        temp := compare(v1[i],v2[i])
        if temp != 0{
            return temp
        }
        i++
    }
    for i < len(v1){
        if re,_ := strconv.ParseInt(v1[i],10,32);re != 0{
            return 1
        }
        i++
    }
    for i < len(v2){
        if re,_ := strconv.ParseInt(v2[i],10,32);re != 0{
            return -1
        }
        i++
    }
    return 0
}

func compare(s1 string,s2 string) int{
    num1,num2 := 0,0
    for _,v := range s1{
        num1 = num1 * 10 + int(v) - 48
    }
    for _,v := range s2{
        num2 = num2 * 10 + int(v) - 48
    }
    if num1 > num2{
        return 1
    }else if num1 < num2{
        return -1
    }else{
        return 0
    }
}

总结

今天实际上也是做了一道中等题没做出来换了另一道，而且还是同样的背包问题，但是今天做那个题压根没想到能用背包问题解，感觉还是要再看看。剩下今天这四道都不难，比较常规