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

2185. 统计包含给定前缀的字符串-简单

题目描述：
给你一个字符串数组 words 和一个字符串 pref 。
返回 words 中以 pref 作为 前缀 的字符串的数目。
字符串 s 的 前缀 就是 s 的任一前导连续字符串。

题解：
将words中的所有字符串切割出pref一样长的前缀，比较二者是否相等即可

代码（Go）：

func prefixCount(words []string, pref string) int {
    re := 0
    for _,v := range words{
        if len(v) >= len(pref){
            if v[:len(pref)] == pref{
                re++
            }
        }
    }
    return re
}

760. 找出变位映射-简单

题目描述：
给定两个列表 Aand B，并且 B 是 A 的变位（即 B 是由 A 中的元素随机排列后组成的新列表）。
我们希望找出一个从 A 到 B 的索引映射 P 。一个映射 P[i] = j 指的是列表 A 中的第 i 个元素出现于列表 B 中的第 j 个元素上。
列表 A 和 B 可能出现重复元素。如果有多于一种答案，输出任意一种。

题解：
直接哈希表即可

代码（Go）：

func anagramMappings(nums1 []int, nums2 []int) []int {
    dict := map[int]int{}
    for i,v := range nums2{
        dict[v] = i
    }
    for i,v := range nums1{
        nums1[i] = dict[v]
    }
    return nums1
}

63. 不同路径 II-中等

题目描述：
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？
网格中的障碍物和空位置分别用 1 和 0 来表示。

题解：
动态规划常规方法

代码（Go）：

func uniquePathsWithObstacles(obstacleGrid [][]int) int {
    dp := make([][]int,len(obstacleGrid))
    for i,_ := range dp{
        temp := make([]int,len(obstacleGrid[0]))
        dp[i] = temp
    }
    for i := 0;i < len(obstacleGrid);i++{
        for j := 0;j < len(obstacleGrid[0]);j++{
            if obstacleGrid[i][j] == 1{
                dp[i][j] = 0
            }else if i == 0 && j == 0{
                dp[i][j] = 1
            }else if i == 0{
                dp[i][j] = dp[i][j - 1]
            }else if j == 0{
                dp[i][j] = dp[i - 1][j]
            }else{
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
            }
        }
    }
    return dp[len(obstacleGrid) - 1][len(obstacleGrid[0]) - 1]
}

300. 最长递增子序列-中等

题目描述：
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

题解：
动态规划，每一个元素结尾的递增子序列设为dp[i]，它的最大长度等于它前面所有比它小的元素的最大长度加一，将每一个位置结尾的最长递增子序列找出后遍历dp，找到最大的长度

代码（Go）：

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

总结

感觉矩阵形式的动态规划现在还可以，数组形式的也稍微入门了，目前只有字符串形式的动态规划依然一窍不通