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

1624. 两个相同字符之间的最长子字符串-简单

题目描述：
给你一个字符串 s，请你返回 两个相同字符之间的最长子字符串的长度 ，计算长度时不含这两个字符。如果不存在这样的子字符串，返回 -1 。
子字符串 是字符串中的一个连续字符序列。

题解：
哈希表存储第一次出现的位置+1，再次出现时计算距离即可

代码（Go）：

func maxLengthBetweenEqualCharacters(s string) int {
    re := -1
    dict := map[rune]int{}
    for i,v := range s{
        if dict[v] == 0{
            dict[v] = i + 1
        }else{
            if i - dict[v] > re{
                re = i - dict[v]
            }
        }
    }
    return re
}

2269. 找到一个数字的 K 美丽值-简单

题目描述：
一个整数 num 的 k 美丽值定义为 num 中符合以下条件的 子字符串 数目：
子字符串长度为 k 。
子字符串能整除 num 。
给你整数 num 和 k ，请你返回 num 的 k 美丽值。
注意：
允许有 前缀 0 。
0 不能整除任何值。
一个 子字符串 是一个字符串里的连续一段字符序列。

题解：
转换成字符串之后滑动窗口判断即可

代码（Go）：

func divisorSubstrings(num int, k int) int {
    re := 0
    s := strconv.Itoa(num)
    for i := k;i <= len(s);i++{
        temp := s[i - k:i]
        tempnum,_ := strconv.Atoi(temp)
        if tempnum != 0 && num % tempnum == 0{
            re++
        }
    }
    return re
}

1143. 最长公共子序列-中等

题目描述：
给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

题解：
之前没做出来的题，二维动态规划，用dp[i][j]表示长度分别为i和j的text1和text2之间的最长公共子序列。如果两个子序列的新增字符text1[i]和text2[j]相等，则dp[i][j]就等于dp[i-1][j-1]再加一，如果不相等就等于dp[i-1][j]和dp[i][j-1]中的最大值

代码（Go）：

func longestCommonSubsequence(text1, text2 string) int {
    m,n := len(text1),len(text2)
    dp := make([][]int, m + 1)
    for i := range dp{
        dp[i] = make([]int, n + 1)
    }
    for i,v1 := range text1{
        for j,v2 := range text2{
            if v1 == v2 {
                dp[i + 1][j + 1] = dp[i][j] + 1
            }else{
                dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j])
            }
        }
    }
    return dp[m][n]
}

func max(x int, y int) int {
    if x > y {
        return x
    }
    return y
}

2140. 解决智力问题-中等

题目描述：
给你一个下标从 0 开始的二维整数数组 questions ，其中 questions[i] = [pointsi, brainpoweri] 。
这个数组表示一场考试里的一系列题目，你需要 按顺序 （也就是从问题 0 开始依次解决），针对每个问题选择 解决 或者 跳过 操作。解决问题 i 将让你 获得 pointsi 的分数，但是你将 无法 解决接下来的 brainpoweri 个问题（即只能跳过接下来的 brainpoweri 个问题）。如果你跳过问题 i ，你可以对下一个问题决定使用哪种操作。
比方说，给你 questions = [[3, 2], [4, 3], [4, 4], [2, 5]] ：
如果问题 0 被解决了， 那么你可以获得 3 分，但你不能解决问题 1 和 2 。
如果你跳过问题 0 ，且解决问题 1 ，你将获得 4 分但是不能解决问题 2 和 3 。
请你返回这场考试里你能获得的 最高 分数。

题解：
这个题没通过，超时了，用解决最长递增子序列的传统方法向前遍历做的，但是整个题数据量很大没通过，但是还是放一下失败的题解吧，过段时间再回来做一遍

代码（Go）：

func mostPoints(questions [][]int) int64 {
    dp := make([]int,len(questions))
    dp[0] = questions[0][0]
    for i := 1;i < len(questions);i++{
        temp := 0
        for j := 0;j < i;j++{
            if questions[j][1] < i - j{
                if dp[j] > temp{
                    temp = dp[j]
                }
            }
        }
        dp[i] = temp + questions[i][0]
    }
    re := 0
    for _,v := range dp{
        if v > re{
            re = v
        }
    }
    return int64(re)
}

总结

最后一个题写的时候大意了，写到最后发现返回值是int64类型我就觉得要超时，最近比较忙就先这样，过段时间忘差不多了再重新做