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

119. 杨辉三角 II-简单

题目描述：
给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。
在「杨辉三角」中，每个数是它左上方和右上方的数的和。

题解：
递归，使用上一行的数据计算下一行

代码（Go）：

func getRow(rowIndex int) []int {
    if rowIndex == 0{
        return []int{1}
    }else if rowIndex == 1{
        return []int{1,1}
    }
    temp := getRow(rowIndex - 1)
    var sce = make([]int,rowIndex + 1)
    sce[0] = 1
    sce[rowIndex] = 1
    for i := 1;i < rowIndex;i++{
        sce[i] = temp[i - 1] + temp[i]
    }
    return sce
}

290. 单词规律-简单

题目描述：
给定一种规律 pattern 和一个字符串 s ，判断 s 是否遵循相同的规律。
这里的 遵循 指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。

题解：
建立两个哈希表进行双向映射

代码（Go）：

func wordPattern(pattern string, s string) bool {
    arr := strings.Split(s," ")
    if len(pattern) != len(arr){
        return false
    }
    var dict = map[byte]string{}
    for i := 0;i < len(pattern);i++{
        if v,ok := dict[pattern[i]];ok{
            if v != arr[i]{
                return false
            }
        }else{
            dict[pattern[i]] = arr[i]
        }
    }
    var dictre = map[string]byte{}
    for i := 0;i < len(pattern);i++{
        if v,ok := dictre[arr[i]];ok{
            if v != pattern[i]{
                return false
            }
        }else{
            dictre[arr[i]] = pattern[i]
        }
    }
    return true
}

414. 第三大的数-简单

题目描述：
给你一个非空数组，返回此数组中 第三大的数 。如果不存在，则返回数组中最大的数。

题解：
用三个变量分别存储最大，次大和第三大的数就可以了，整体思路有点像大量数据的堆排序

代码（Go）：

func thirdMax(nums []int) int {
    first, second, third := math.MinInt64, math.MinInt64, math.MinInt64
    for _, num := range nums {
        if num > first {
            first, second, third = num, first, second
        } else if first > num && num > second {
            second, third = num, second
        } else if second > num && num > third {
            third = num
        }
    }
    if third == math.MinInt64 {
        return first
    }
    return third
}

55. 跳跃游戏-中等

题目描述：
给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。

题解：
从后向前遍历，如果一个点不可达则将其跳跃长度置为0，若一个点可达的所有节点跳跃长度均为0，则它本身也相当于0，遍历到数组的第一个元素，若他不为0则可达最后下标。时间复杂度比较高，用时很久。官方题解采用了很妙的思路，从前往后看数组，若一个点能跳到一个很远的距离，那就说明这之间的点它都可以到达，所以只需要维护一个最远跳跃距离，就可以通过一次遍历数组更新最远距离求解，若最远距离大于数组长度则说明可达最后下标

代码（Go）：

func canJump(nums []int) bool {
    if len(nums) == 1{
        return true
    }
    nums[len(nums) - 1] = 1
    for i := len(nums) - 2;i >= 0;i--{
        flag := 0
        for j := 0;j < nums[i];j++{
            if i + j + 1 < len(nums) && nums[i + j + 1] != 0{
                flag = 1
            }
        }
        if flag == 0{
            nums[i] = 0
        }
    }
    if nums[0] == 0{
        return false
    }
    return true
}

总结

简单题还好，感觉中等题开始上强度了，今天做题之前瞄了一眼看到好几个之前找工作时候的笔试面试题，但是都想不起来怎么做了，今天的中等题已经是挑了个软柿子捏了