从零开始的力扣刷题记录-第四十二天-Toy模板网

这篇具有很好参考价值的文章主要介绍了从零开始的力扣刷题记录-第四十二天。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1790. 仅执行一次字符串交换能否使两个字符串相等-简单

题目描述：
给你长度相等的两个字符串 s1 和 s2 。一次字符串交换操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。
如果对其中一个字符串执行最多一次字符串交换就可以使两个字符串相等，返回 true ；否则，返回 false 。

题解：
前面做过一道和这个题一样的，区别就是那个题必须强制交换一次，所以相等的时候返回值不一样，其他一模一样

代码（Go）：

func areAlmostEqual(s1 string, s2 string) bool {
    if s1 == s2{
        return true
    }
    if len(s1) != len(s2){
        return false
    }
    temp := 0
    p,q := 0,0
    for i := 0;i < len(s1);i++{
        if s1[i] != s2[i]{
            temp++
            if temp == 1{
                p = i
            }else{
                q = i
            }
        }
        if temp > 2{
            return false
        }
    }
    if temp == 2{
        if s1[p] == s2[q] && s1[q] == s2[p]{
            return true
        }
    }
    return false
}

1800. 最大升序子数组和-简单

题目描述：
给你一个正整数组成的数组 nums ，返回 nums 中一个升序子数组的最大可能元素和。
子数组是数组中的一个连续数字序列。
已知子数组 [numsl, numsl+1, …, numsr-1, numsr] ，若对所有 i（l <= i < r），numsi < numsi+1 都成立，则称这一子数组为升序子数组。注意，大小为 1 的子数组也视作升序子数组。

题解：
遍历一次数组，遇到降序就从零开始计算temp，遇到升序就累加到temp中，最后比较temp与max的大小，把大数保存起来。看了官方题解才发现这是动态规划的思想

代码（Go）：

func maxAscendingSum(nums []int) int {
    temp := nums[0]
    max := temp
    for i := 1;i < len(nums);i++{
        if nums[i] > nums[i - 1]{
            temp += nums[i]
        }else{
            temp = nums[i]
        }
        if temp > max{
            max = temp
        }
    }
    return max
}

1748. 唯一元素的和-简单

题目描述：
给你一个整数数组 nums 。数组中唯一元素是那些只出现恰好一次的元素。
请你返回 nums 中唯一元素的和。

题解：
哈希表记录出现次数，遍历哈希表将出现次数为1的数加起来。官方题解还可以再优化，遍历数组时第一次遇到一个数就加起来，如果后续再遇到这个数就减掉，这个方法只需要遍历一次数组不需要遍历哈希表

代码（Go）：

func sumOfUnique(nums []int) int {
    dict := map[int]int{}
    for _,v := range nums{
        if _,ok := dict[v];ok{
            dict[v]++
        }else{
            dict[v] = 1
        }
    }
    sum := 0
    for i,v := range dict{
        if v == 1{
            sum += i
        }
    }
    return sum
}

1110. 删点成林-中等

题目描述：
给出二叉树的根节点 root，树上每个节点都有一个不同的值。
如果节点值在 to_delete 中出现，我们就把该节点从树上删去，最后得到一个森林（一些不相交的树构成的集合）。
返回森林中的每棵树。你可以按任意顺序组织答案。

题解：
判断节点是否需要被删除如果需要被删除，则递归判断它的两个子节点，并且两个子节点可能加入节点序列，若不需要删除依旧递归遍历它的两个子节点，但是子节点不能加入节点序列

代码（Go）：

func delNodes(root *TreeNode, to_delete []int) []*TreeNode {
    re := []*TreeNode{}
    var delNode func(root *TreeNode,to_delete []int,add int)
    delNode = func(root *TreeNode,to_delete []int,add int){
        if inDelete(root.Val,to_delete){
            if root.Left != nil{
                delNode(root.Left,to_delete,1)
            }
            if root.Right != nil{
                delNode(root.Right,to_delete,1)
            }
        }else{
            if root.Left != nil{
                delNode(root.Left,to_delete,0)
                if inDelete(root.Left.Val,to_delete){
                    root.Left = nil
                }
            }
            if root.Right != nil{
                delNode(root.Right,to_delete,0)
                if inDelete(root.Right.Val,to_delete){
                    root.Right = nil
                }
            }
            if add == 1{
                re = append(re,root)
            }
        }
    }
    delNode(root,to_delete,1)
    return re
}

func inDelete(i int,to_delete []int) bool {
    for _,v := range to_delete{
        if v == i{
            return true
        }
    }
    return false
}