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

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
}

总结

简单题提交数1000以上的题已经做遍了，接下来还有一些重复的题和提交数比较少的题，本来是想的开始一天两道中等题，但是最近比较忙，所以先继续一天3道，等忙完这阵就开始加到两道中等题