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

252. 会议室-简单

题目描述：
给定一个会议时间安排的数组 intervals ，每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ，请你判断一个人是否能够参加这里面的全部会议。

题解：
排序之后比较相邻两个会议的起始时间和结束时间即可

代码（Go）：

func canAttendMeetings(intervals [][]int) bool {
    sort.Slice(intervals, func(i, j int) bool {
        a, b := intervals[i], intervals[j]
        return a[0] < b[0]
    })
    for i := 1;i < len(intervals);i++{
        if intervals[i][0] < intervals[i - 1][1]{
            return false
        }
    }
    return true
}

1636. 按照频率将数组升序排序-简单

题目描述：
给你一个整数数组 nums ，请你将数组按照每个值的频率 升序 排序。如果有多个值的频率相同，请你按照数值本身将它们 降序 排序。
请你返回排序后的数组。

题解：
哈希表存储出现的频率，然后就可以根据频率和数值进行排序了

代码（Go）：

func frequencySort(nums []int) []int {
    fre := map[int]int{}
    for _,v := range nums{
        fre[v]++
    }
    sort.Slice(nums,func(i int,j int)bool{
        a,b := nums[i],nums[j]
        return fre[a] < fre[b] ||(fre[a] == fre[b] && a > b)
    })
    return nums
}

1539. 第 k 个缺失的正整数-简单

题目描述：
给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。
请你找到这个数组里第 k 个缺失的正整数。

题解：
常规做法逐个遍历对比做的，官方题解可以二分法做，时间复杂度更低，我做的时候确实是完全没往二分法上想

题解：

func findKthPositive(arr []int, k int) int {
    i := 0
    re := 1
    flag := 0
    for flag <= k{
        if arr[i] != re{
            flag++
            if flag == k{
                return re
            }
            re++
        }else{
            re++
            if i < len(arr) - 1{
                i++
            }
        }
    }
    return 1
}

131. 分割回文串-中等

题目描述：
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。

题解：
依然是回溯常规流程，使用一个start标记起点，终止条件隐含在for循环中了，此外由于回文串至少有一个字符，所以for循环遍历时i<len(s)-1，通过decide函数判断回文串，是回文串就加入结果集。官方题解对判断回文串进行了优化，由于每次判断回文串都要遍历一遍字符串s导致时间复杂度较高，通过动态规划的方式可以提前将子串是否为回文串存储起来，这样只需要O(1)的时间复杂度即可判断是否为回文串

代码（Go）：

func partition(s string) [][]string {
    re := [][]string{}
    var backtrack func(s string,start int)
    backtrack = func(s string,start int){
        temp := strings.Split(s,",")
        if decide(temp[len(temp) - 1]){
            re = append(re,temp)
        }
        var temps string
        for i := start;i < len(s) - 1;i++{
            temps += string(s[i])
            if decide(temps){
                backtrack(s[:i + 1] + "," + s[i + 1:],i + 2)
            }
        }
    }
    backtrack(s,0)
    return re
}

func decide(s string) bool {
    i,j := 0,len(s) - 1
    for i < j{
        if s[i] != s[j]{
            return false
        }
        i++
        j--
    }
    return true
}

总结

简单题练习了一下go语言里自定义排序规则的排序函数，中等题依然是回溯，感觉现在已经不用特意针对回溯练习了，明天准备开始两道中等题了，接下来想专项练习一下动态规划