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

938. 二叉搜索树的范围和-简单

题目描述：
给定二叉搜索树的根结点 root，返回值位于范围 [low, high] 之间的所有结点的值的和。

题解：
递归遍历，遇到小于low的值就不需要遍历左子树，遇到大于high的值就不需要遍历右子树，二者之间的值加起来得到结果

代码（Go）：

func rangeSumBST(root *TreeNode, low int, high int) int {
    sum := 0
    var search func(root *TreeNode)
    search = func(root *TreeNode){
        if root == nil{
            return
        }
        if root.Val > low{
            search(root.Left)
        }
        if root.Val >= low && root.Val <= high{
            sum += root.Val
        }
        if root.Val < high{
            search(root.Right)
        }
        return
    }
    search(root)
    return sum
}

1025. 除数博弈-简单

题目描述：
爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。
最初，黑板上有一个数字 n 。在每个玩家的回合，玩家需要执行以下操作：
选出任一 x，满足 0 < x < n 且 n % x == 0 。
用 n - x 替换黑板上的数字 n 。
如果玩家无法执行这些操作，就会输掉游戏。
只有在爱丽丝在游戏中取得胜利时才返回 true 。假设两个玩家都以最佳状态参与游戏。

题解：
看着挺复杂本来想动态规划但是算了几个前置条件发现怎么好像偶数必胜奇数必输，试试写了个代码真通过了，不过还是贴一下动态规划吧，数学方法对练习算法没啥帮助

代码（Go）：

func divisorGame(n int) bool {
    f := make([]bool, n + 5)
    f[1], f[2] = false, true
    for i := 3; i <= n; i++ {
        for j := 1; j < i; j++ {
            if i % j == 0 && !f[i - j] {
                f[i] = true
                break
            }
        }
    }
    return f[n]
}

1089. 复写零-简单

题目描述：
给你一个长度固定的整数数组 arr ，请你将该数组中出现的每个零都复写一遍，并将其余的元素向右平移。
注意：请不要在超过该数组长度的位置写入元素。请对输入的数组 就地 进行上述修改，不要从函数返回任何东西。

题解：
这题真的是写代码5分钟改代码半小时，思路很简单就是遍历一次数组记录从后往前插元素时的起始元素然后一次往前插就可以了，但是实际运行时有很多边界条件，比如最后单独插一个0的情况，以及计算起始元素的时候怎么加才能得到起始元素

代码（Go）：

func duplicateZeros(arr []int)  {
    l := -1
    i := 0
    for i < len(arr){
        l++
        if arr[l] == 0{
            i += 2
        }else{
            i++
        }
    }
    j := len(arr) - 1
    if i == len(arr) + 1{
        arr[j] = 0
        j--
        l--
    }
    for j >= 0{
        if arr[l] != 0{
            arr[j] = arr[l]
            l--
        }else{
            arr[j] = 0
            if j != 0{
                arr[j - 1] = 0
            }
            j--
            l--
        }
        j--
    }
    return
}

1130. 叶值的最小代价生成树-中等

题目描述：
给你一个正整数数组 arr，考虑所有满足以下条件的二叉树：
每个节点都有 0 个或是 2 个子节点。
数组 arr 中的值与树的中序遍历中每个叶节点的值一一对应。
每个非叶节点的值等于其左子树和右子树中叶节点的最大值的乘积。
在所有这样的二叉树中，返回每个非叶节点的值的最小可能总和。这个和的值是一个 32 位整数。
如果一个节点有 0 个子节点，那么该节点为叶节点。

题解：
一开始忘了中序遍历与arr值一一对应这条，用构造哈夫曼树的方法做的，结果发现我算出来的比答案小，咋也找不出问题，一看答案才发现自己题目看的不仔细，实际上思想也差不多，只不过我之前是用的数组排序，如果要求与中序遍历对应的话就需要一个单调栈，不需要找最小的两个数了，只需要找一个数的左右两个数，永远和比较小的那个数相乘

代码（Go）：

func mctFromLeafValues(arr []int) int {
    res, stk := 0, []int{}
    for _, x := range arr {
        for len(stk) > 0 && stk[len(stk) - 1] <= x {
            if len(stk) == 1 || stk[len(stk) - 2] > x {
                res += stk[len(stk) - 1] * x
            } else {
                res += stk[len(stk) - 2] * stk[len(stk) - 1]
            }
            stk = stk[:len(stk)-1]
        }
        stk = append(stk, x)
    }
    for len(stk) > 1 {
        res += stk[len(stk) - 2] * stk[len(stk) - 1]
        stk = stk[:len(stk)-1]
    }
    return res
}

总结

今天有点一波三折，先是简单题改代码改半天，后有中等题题目少看个条件导致找半天没找出问题看了答案，只能说以后尽量避免这种低级错误