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

976. 三角形的最大周长-简单

题目描述：
给定由一些正数（代表长度）组成的数组 nums ，返回 由其中三个长度组成的、面积不为零的三角形的最大周长 。如果不能形成任何面积不为零的三角形，返回 0。

题解：
排序后从后往前遍历，取最大的三个边，如果满足两边之和大于第三边则返回，否则整体向前移一位

代码（Go）：

func largestPerimeter(a []int) int {
    sort.Ints(a)
    for i := len(a) - 1; i >= 2; i-- {
        if a[i-2]+a[i-1] > a[i] {
            return a[i-2] + a[i-1] + a[i]
        }
    }
    return 0
}

2347. 最好的扑克手牌-简单

题目描述：
给你一个整数数组 ranks 和一个字符数组 suit 。你有 5 张扑克牌，第 i 张牌大小为 ranks[i] ，花色为 suits[i] 。
下述是从好到坏你可能持有的 手牌类型 ：
“Flush”：同花，五张相同花色的扑克牌。
“Three of a Kind”：三条，有 3 张大小相同的扑克牌。
“Pair”：对子，两张大小一样的扑克牌。
“High Card”：高牌，五张大小互不相同的扑克牌。
请你返回一个字符串，表示给定的 5 张牌中，你能组成的 最好手牌类型 。
注意：返回的字符串 大小写 需与题目描述相同。

题解：
哈希表计数，按题目描述模拟即可

代码（Go）：

func bestHand(ranks []int, suits []byte) string {
    temps := suits[0]
    flags := 1
    for _,v := range suits{
        if v != temps{
            flags = 0
        }
    }
    if flags == 1{
        return "Flush"
    }
    dict := map[int]int{}
    for _,v := range ranks{
        dict[v]++
    }
    tempi := 0
    for _,v := range dict{
        if v >= 3 {
            return "Three of a Kind"
        }
        if v == 2{
            tempi = 1
        }
    }
    if tempi == 1{
        return "Pair"
    }
    return "High Card"
}

1254. 统计封闭岛屿的数目-中等

题目描述：
二维矩阵 grid 由 0 （土地）和 1 （水）组成。岛是由最大的4个方向连通的 0 组成的群，封闭岛是一个 完全 由1包围（左、上、右、下）的岛。
请返回 封闭岛屿 的数目。

题解：
和之前做过的岛屿数量题一个思路，找到一个土地块后以此为起点将周围所有土地都标记为2，区别是若扩散过程中遇到边界则封闭岛屿数量不增加

代码（Go）：

func closedIsland(grid [][]int) int {
    re := 0
    for i := 0;i < len(grid);i++{
        for j := 0;j < len(grid[0]);j++{
            if grid[i][j] == 0{
                temp := 0
                grid,temp = flag(grid,i,j,temp)
                if temp == 0{
                    re++
                }
            }
        }
    }
    return re
}

func flag(grid [][]int,i int,j int,k int) ([][]int , int){
    k1,k2,k3,k4 := 0,0,0,0
    if i - 1 >= 0{
        if grid[i - 1][j] == 0{
            grid[i - 1][j] = 2
            grid,k1 = flag(grid,i - 1,j,k)
        }
    }else{
        k1 = 1
    }
    if j - 1 >= 0{
        if grid[i][j - 1] == 0{
            grid[i][j - 1] = 2
            grid,k2 = flag(grid,i,j - 1,k)
        }
    }else{
        k2 = 1
    }
    if i + 1 < len(grid){
        if grid[i + 1][j] == 0{
            grid[i + 1][j] = 2
            grid,k3 = flag(grid,i + 1,j,k)
        }
    }else{
        k3 = 1
    }
    if j + 1 < len(grid[0]){
        if grid[i][j + 1] == 0{
            grid[i][j + 1] = 2
            grid,k4 = flag(grid,i,j + 1,k)
        }
    }else{
        k4 = 1
    }
    return grid,k1 | k2 | k3 | k4
}

120. 三角形最小路径和-中等

题目描述：
给定一个三角形 triangle ，找出自顶向下的最小路径和。
每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

题解：
动态规划，自上而下遍历三角形数组，每个点只可能由上层节点或上层节点的前一个节点移动而来，只需要比较二者大小，将小的与本身相加，就得到了本节点的最小路径，最后遍历三角形数组的最后一层，找出路径和最小的节点即可

代码（Go）：

func minimumTotal(triangle [][]int) int {
    for i := 0;i < len(triangle);i++{
        for j := 0;j < len(triangle[i]);j++{
            if i > 0{
                if j == 0{
                    triangle[i][j] += triangle[i - 1][j]
                }else if j == len(triangle[i]) - 1{
                    triangle[i][j] += triangle[i - 1][j - 1]
                }else{
                    if triangle[i - 1][j] > triangle[i - 1][j - 1]{
                        triangle[i][j] += triangle[i - 1][j - 1]
                    }else{
                        triangle[i][j] += triangle[i - 1][j]
                    }
                }
            }
        }
    }
    re := 10000000
    for _,v := range triangle[len(triangle) - 1]{
        if v < re{
            re = v
        }
    }
    return re
}

总结

动态规划需要思考的地方还是很多的，今天这道动态规划实际上是做的第二道，最开始做的那道动态规划没看出来递推关系，感觉动态规划还是需要练一段时间的