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

599. 两个列表的最小索引总和-简单

题目描述：
假设 Andy 和 Doris 想在晚餐时选择一家餐厅，并且他们都有一个表示最喜爱餐厅的列表，每个餐厅的名字用字符串表示。
你需要帮助他们用最少的索引和找出他们共同喜爱的餐厅。 如果答案不止一个，则输出所有答案并且不考虑顺序。 你可以假设答案总是存在。

题解：
哈希表存储list1感兴趣的餐厅及其索引位置，遍历list2找出最小索引再遍历一遍list2将等于最小索引的餐厅加入结果集。官方题解还可以优化，遍历list2时将等于当前最小索引的餐厅加入结果集，如果遍历到小于当前索引的餐厅，则清空结果集并更新当前最小索引，这样只需要遍历一次list2

代码（Go）：

func findRestaurant(list1 []string, list2 []string) []string {
    dict := map[string]int{}
    for i,v := range list1{
        dict[v] = i
    }
    min := len(list1) + len(list2)
    minstring := []string{}
    for i,v := range list2{
        if num,ok := dict[v];ok{
            if num + i < min{
                min = num + i
            }
        }
    }
    for i,v := range list2{
        if num,ok := dict[v];ok{
            if num + i == min{
                minstring = append(minstring,v)
            }
        }
    }
    return minstring
}

1893. 检查是否区域内所有整数都被覆盖-简单

题目描述：
给你一个二维整数数组 ranges 和两个整数 left 和 right 。每个 ranges[i] = [starti, endi] 表示一个从 starti 到 endi 的 闭区间 。
如果闭区间 [left, right] 内每个整数都被 ranges 中 至少一个 区间覆盖，那么请你返回 true ，否则返回 false 。
已知区间 ranges[i] = [starti, endi] ，如果整数 x 满足 starti <= x <= endi ，那么我们称整数x 被覆盖了。

题解：
因为数组中的数上限只有50所以使用一个数组表示该元素是否在ranges中出现，在循环判断left到right范围的数是否在ranges中

代码（Go）：

func isCovered(ranges [][]int, left int, right int) bool {
    arr := [51]int{}
    for _,v := range ranges{
        for i := v[0];i <= v[1];i++{
            arr[i] = 1
        }
    }
    for i := left;i <= right;i++{
        if arr[i] != 1{
            return false
        }
    }
    return true
}

1779. 找到最近的有相同 X 或 Y 坐标的点-简单

题目描述：
给你两个整数 x 和 y ，表示你在一个笛卡尔坐标系下的 (x, y) 处。同时，在同一个坐标系下给你一个数组 points ，其中 points[i] = [ai, bi] 表示在 (ai, bi) 处有一个点。当一个点与你所在的位置有相同的 x 坐标或者相同的 y 坐标时，我们称这个点是 有效的 。
请返回距离你当前位置 曼哈顿距离 最近的 有效 点的下标（下标从 0 开始）。如果有多个最近的有效点，请返回下标 最小 的一个。如果没有有效点，请返回 -1 。
两个点 (x1, y1) 和 (x2, y2) 之间的 曼哈顿距离 为 abs(x1 - x2) + abs(y1 - y2) 。

题解：
遍历一遍数组，用一个变量保存最小距离，一个保存下标。

代码（Go）：

func nearestValidPoint(x int, y int, points [][]int) int {
    var len float64 = 100000
    re := -1
    for i,v := range points{
        if v[0] == x || v[1] == y{
            if math.Abs(float64(v[0] - x)) + math.Abs(float64(v[1] - y)) < len{
                len = math.Abs(float64(v[0] - x)) + math.Abs(float64(v[1] - y))
                re = i
            }
        }
    }
    return re
}

45. 跳跃游戏 II-中等

题目描述：
给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。
每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:
0 <= j <= nums[i]
i + j < n
返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

题解：
动态规划，维护一个数组表示跳跃到下标位置所需的最小步数，遍历给出的数组，从索引i向前跳跃的范围内跳跃的步数是dp[i]+1，我们只需判断dp[i]+1和dp[j]的大小即可。官方解法使用贪心的思想可以用O(n)的时间复杂度解出，比动态规划更优

代码（Go）：

func jump(nums []int) int {
    dp := make([]int,len(nums))
    for i,_ := range dp{
        dp[i] = 10001
    }
    dp[0] = 0
    for i := 0;i < len(nums);i++{
        for j := i + 1;j <= i + nums[i] && j < len(nums);j++{
            if dp[j] > dp[i] + 1{
                dp[j] = dp[i] + 1
            }
        }
    }
    return dp[len(nums) - 1]
}

总结

今天的简单题很简单，中等题虽然做得很快但是没能想到最佳时间复杂度的方法