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

953. 验证外星语词典-简单

题目描述：
某种外星语也使用英文小写字母，但可能顺序 order 不同。字母表的顺序（order）是一些小写字母的排列。
给定一组用外星语书写的单词 words，以及其字母表的顺序 order，只有当给定的单词在这种外星语中按字典序排列时，返回 true；否则，返回 false。

题解：
把字母表转换成数值索引，数值大的优先级高，只需要比较数字大小即可。循环过程参考了一下答案，我自己写的还要引入新变量判断状态，官方题解使用next帮助跳转，代码简洁了很多

代码（Go）：

func isAlienSorted(words []string, order string) bool {
    arr := [26]int{}
    for i, v := range order {
        arr[v - 'a'] = i
    }
    next:
    for i := 1; i < len(words); i++ {
        for j := 0; j < len(words[i - 1]) && j < len(words[i]); j++ {
            p, q := arr[words[i - 1][j] - 'a'], arr[words[i][j] - 'a']
            if p > q {
                return false
            }
            if p < q {
                continue next
            }
        }
        if len(words[i-1]) > len(words[i]) {
            return false
        }
    }
    return true
}

896. 单调数列-简单

题目描述：
如果数组是单调递增或单调递减的，那么它是 单调 的。
如果对于所有 i <= j，nums[i] <= nums[j]，那么数组 nums 是单调递增的。 如果对于所有 i <= j，nums[i]> = nums[j]，那么数组 nums 是单调递减的。
当给定的数组 nums 是单调数组时返回 true，否则返回 false。

题解：
判断一下是递增还是递减，然后按着这个规律判断后面所有的元素。官方题解有更好的办法，只需要一次遍历记录记录是否出现过递增和递减，然后判断二者是否同时出现即可

代码（Go）：

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

1470. 重新排列数组-简单

题目描述：
给你一个数组 nums ，数组中有 2n 个元素，按 [x1,x2,…,xn,y1,y2,…,yn] 的格式排列。
请你将数组按 [x1,y1,x2,y2,…,xn,yn] 格式重新排列，返回重排后的数组。

题解：
双指针分别指向前半段和后半段的起点，然后归并即可。

代码（Go）：

func shuffle(nums []int, n int) []int {
    re := make([]int,len(nums))
    i := 0
    p := 0
    for j := len(nums)/2;j < len(nums);j++{
        re[p] = nums[i]
        p++
        re[p] = nums[j]
        p++
        i++
    }
    return re
}

78. 子集-中等

题目描述：
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

题解：
回溯，终止条件就是枚举到最后一个元素，即start > len(nums)，为了不让回溯时枚举到重复元素，需要传递一个起始值指明从第几个元素开始枚举，起始值每次加一即可

代码（Go）：

func subsets(nums []int) [][]int {
    re := [][]int{}
    var backtrack func(sce []int,start int)
    backtrack = func(sce []int,start int){
        temp := make([]int, len(sce))
        copy(temp,sce)
        re = append(re,temp)
        for i := start;i < len(nums);i++{
            sce = append(sce,nums[i])
            backtrack(sce,i + 1)
            sce = sce[:len(sce) - 1]
        }
    }
    sce := []int{}
    backtrack(sce,0)
    return re
}

总结

继续玩回溯，接下来几天预计每天一道回溯，彻底把回溯做明白