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

2490. 回环句-简单

题目描述：
句子 是由单个空格分隔的一组单词，且不含前导或尾随空格。
例如，“Hello World”、“HELLO”、“hello world hello world” 都是符合要求的句子。
单词 仅 由大写和小写英文字母组成。且大写和小写字母会视作不同字符。
如果句子满足下述全部条件，则认为它是一个 回环句 ：
单词的最后一个字符和下一个单词的第一个字符相等。
最后一个单词的最后一个字符和第一个单词的第一个字符相等。
例如，“leetcode exercises sound delightful”、“eetcode”、“leetcode eats soul” 都是回环句。然而，“Leetcode is cool”、“happy Leetcode”、“Leetcode” 和 “I like Leetcode” 都 不 是回环句。
给你一个字符串 sentence ，请你判断它是不是一个回环句。如果是，返回 true ；否则，返回 false 。

题解：
按题目描述遍历并比较

代码（Go）：

func isCircularSentence(sentence string) bool {
    s := strings.Split(sentence," ")
    for i := 0;i < len(s);i++{
        if i == len(s) - 1{
            if s[i][len(s[i]) - 1] != s[0][0]{
                return false
            }
        }else{
            if s[i][len(s[i]) - 1] != s[i + 1][0]{
                return false
            }
        }
    }
    return true
}

1295. 统计位数为偶数的数字-简单

题目描述：
给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。

题解：
转换成字符串查看长度是否能整除2即可

代码（Go）：

func findNumbers(nums []int) int {
    re := 0
    for _,v := range nums{
        if len(strconv.Itoa(v)) % 2 == 0{
            re++
        }
    }
    return re
}

646. 最长数对链-中等

题目描述：
给你一个由 n 个数对组成的数对数组 pairs ，其中 pairs[i] = [lefti, righti] 且 lefti < righti 。
现在，我们定义一种 跟随 关系，当且仅当 b < c 时，数对 p2 = [c, d] 才可以跟在 p1 = [a, b] 后面。我们用这种形式来构造 数对链 。
找出并返回能够形成的 最长数对链的长度 。
你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。

题解：
和最长子序列差不多的思路，可以用动态规划也可以用贪心。之前一直用的动态规划，这次用一下贪心。自己写的时候忘了二分法查找，放下官方解

代码（Go）：

func findLongestChain(pairs [][]int) int {
    sort.Slice(pairs, func(i, j int) bool { return pairs[i][0] < pairs[j][0] })
    arr := []int{}
    for _, p := range pairs {
        i := sort.SearchInts(arr, p[0])
        if i < len(arr) {
            arr[i] = min(arr[i], p[1])
        } else {
            arr = append(arr, p[1])
        }
    }
    return len(arr)
}

func min(a, b int) int {
    if a > b {
        return b
    }
    return a
}

1218. 最长定差子序列-中等

题目描述：
给你一个整数数组 arr 和一个整数 difference，请你找出并返回 arr 中最长等差子序列的长度，该子序列中相邻元素之间的差等于 difference 。
子序列 是指在不改变其余元素顺序的情况下，通过删除一些元素或不删除任何元素而从 arr 派生出来的序列。

题解：
这题甚至不要求改变元素顺序，就很简单，直接哈希表作为dp数组即可，每遍历到一个元素都令其dp值等于它的值减去difference的dp值加一，遍历过程中记录最大值即可

代码（Go）：

func longestSubsequence(arr []int, difference int) int {
    re := 0
    dp := map[int]int{}
    for _,v := range arr {
        dp[v] = dp[v - difference] + 1
        if dp[v] > re {
            re = dp[v]
        }
    }
    return re
}

总结

最近又忙起来了，这几天找点软柿子捏