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

2341. 数组能形成多少数对-简单

题目描述：
给你一个下标从 0 开始的整数数组 nums 。在一步操作中，你可以执行以下步骤：
从 nums 选出 两个 相等的 整数
从 nums 中移除这两个整数，形成一个 数对
请你在 nums 上多次执行此操作直到无法继续执行。
返回一个下标从 0 开始、长度为 2 的整数数组 answer 作为答案，其中 answer[0] 是形成的数对数目，answer[1] 是对 nums 尽可能执行上述操作后剩下的整数数目。

题解：
实际上就是统计各元素出现的次数，数对数量就是各元素除以2的和，剩余数量就是各元素对2取余的和

代码（Go）：

func numberOfPairs(nums []int) []int {
    arr := [101]int{}
    for _,v := range nums{
        arr[v]++
    }
    rei,rej := 0,0
    for _,v := range arr{
        rei += v/2
        rej += v%2
    }
    return []int{rei,rej}
}

2383. 赢得比赛需要的最少训练时长-简单

题解：
你正在参加一场比赛，给你两个 正 整数 initialEnergy 和 initialExperience 分别表示你的初始精力和初始经验。
另给你两个下标从 0 开始的整数数组 energy 和 experience，长度均为 n 。
你将会 依次 对上 n 个对手。第 i 个对手的精力和经验分别用 energy[i] 和 experience[i] 表示。当你对上对手时，需要在经验和精力上都 严格 超过对手才能击败他们，然后在可能的情况下继续对上下一个对手。
击败第 i 个对手会使你的经验 增加 experience[i]，但会将你的精力 减少 energy[i] 。
在开始比赛前，你可以训练几个小时。每训练一个小时，你可以选择将增加经验增加 1 或者 将精力增加 1 。
返回击败全部 n 个对手需要训练的 最少 小时数目。

题解：
精力计算比较简单，不需要比较，只需要将所需精力加起来，看目前精力距离所需之和加一还差多少即可。经验由于需要判断大小，所以需要走常规流程模拟整个比赛过程，大于就相加小于就补充差值。

代码（Go）：

func minNumberOfHours(initialEnergy int, initialExperience int, energy []int, experience []int) int {
    for _,v := range energy{
        initialEnergy -= v
    }
    temp := initialExperience
    sumex := 0
    for _,v := range experience{
        if temp > v{
            temp += v
        }else{
            sumex += v - temp + 1
            temp = v*2 + 1
        }
    }
    sumen := 0
    if initialEnergy <= 0{
        sumen += -initialEnergy + 1
    }
    return sumen + sumex
}

1824. 最少侧跳次数-中等

题目描述：
给你一个长度为 n 的 3 跑道道路 ，它总共包含 n + 1 个 点 ，编号为 0 到 n 。一只青蛙从 0 号点第二条跑道 出发 ，它想要跳到点 n 处。然而道路上可能有一些障碍。
给你一个长度为 n + 1 的数组 obstacles ，其中 obstacles[i] （取值范围从 0 到 3）表示在点 i 处的 obstacles[i] 跑道上有一个障碍。如果 obstacles[i] == 0 ，那么点 i 处没有障碍。任何一个点的三条跑道中 最多有一个 障碍。
比方说，如果 obstacles[2] == 1 ，那么说明在点 2 处跑道 1 有障碍。
这只青蛙从点 i 跳到点 i + 1 且跑道不变的前提是点 i + 1 的同一跑道上没有障碍。为了躲避障碍，这只青蛙也可以在 同一个 点处 侧跳 到 另外一条 跑道（这两条跑道可以不相邻），但前提是跳过去的跑道该点处没有障碍。
比方说，这只青蛙可以从点 3 处的跑道 3 跳到点 3 处的跑道 1 。
这只青蛙从点 0 处跑道 2 出发，并想到达点 n 处的 任一跑道 ，请你返回 最少侧跳次数 。
注意：点 0 处和点 n 处的任一跑道都不会有障碍。

题解：
动态规划，把每个点三条跑道的状态作为dp数组，遍历障碍数组，如果此处有障碍就把状态更改为最大值，否则一点的状态等于它同跑道的前一个点和同时刻其他跑道的最小值加一中的最小值。这题思路很好想但是代码很难写，因为一个点的状态要同时受前一个点和当前点两个点的障碍干扰。官方解处理的很巧妙，他先用当前点的障碍更新前一个点的状态，然后再找出其中的最小值，最后才更新当前点的状态，代码就可以做到非常简单易懂，自己写的有点绕，贴下官方解

代码（Go）：

func minSideJumps(obstacles []int) int {
    d := [3]int{1, 0, 1}
    for _, x := range obstacles[1:] {
        minCnt := math.MaxInt / 2
        for j := 0; j < 3; j++ {
            if j == x-1 {
                d[j] = math.MaxInt / 2
            } else {
                minCnt = min(minCnt, d[j])
            }
        }
        for j := 0; j < 3; j++ {
            if j != x-1 {
                d[j] = min(d[j], minCnt+1)
            }
        }
    }
    return min(min(d[0], d[1]), d[2])
}

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

1641. 统计字典序元音字符串的数目-中等

题目描述：
给你一个整数 n，请返回长度为 n 、仅由元音 (a, e, i, o, u) 组成且按 字典序排列 的字符串数量。
字符串 s 按 字典序排列 需要满足：对于所有有效的 i，s[i] 在字母表中的位置总是与 s[i+1] 相同或在 s[i+1] 之前。

题解：
用dp数组表示每一个元音字母结尾的字符串有多少，长度为n以a结尾的字符串要求长度n-1的字符串必须以a结尾，以此类推即可得出以所有元音字母结尾的字符串数量的递推关系，最后计算总和即可

代码（Go）：

func countVowelStrings(n int) int {
    if n == 1{
        return 5
    }
    dp := []int{1,1,1,1,1}
    for i := 2 ;i <= n;i++{
        dp[1] = dp[0] + dp[1]
        dp[2] = dp[1] + dp[2]
        dp[3] = dp[2] + dp[3]
        dp[4] = dp[3] + dp[4]
    }
    return dp[0] + dp[1] + dp[2] + dp[3] + dp[4]
}

总结

动态规划之间亦有差距。今天做的有一道动态规划甚至要三维数组去做，太难了，最后做出来这两道一道是一维的，一道虽然是二维但是代码写了很长时间然后还写得很复杂很乱。接下来一个月保不齐都得耗在动态规划上了