刷题Day18-贪心(5)

738. 单调递增的数字

思路：从最后一位开始，往前推，如果发现某个数字比右边的数字大，那么从指定的位置开始，直到这个数字的右侧，都换成9，然后这个数字-1。然后继续重复这个过程

import (
    "fmt"
    "strconv"
)
func monotoneIncreasingDigits(n int) int {
x := strconv.Itoa(n)
    numbers := make([]int, len(x))
    for i, xx := range x {
        numbers[i] = int(xx - '0')
    }
    end := len(x) - 1
    start := len(x) - 2
    ret := 0
    for start >= 0 {
        if numbers[start] > numbers[start+1] {
            numbers[start]--
            for i := start + 1; i <= end; i++ {
                numbers[i] = 9
            }
            end = start
        }
        start--
    }
    for _, x := range numbers {
        ret *= 10
        ret += x
    }
    return ret
}

---

714. 买卖股票的最佳时机含手续费

用动态规划做

func maxProfit(prices []int, fee int) int {
    dp := make([][]int, len(prices))
    dp[0] = make([]int, 2)
    dp[0][0] = 0
    dp[0][1] = -prices[0]
    for i, x := range prices {
        if i == 0 {
            continue
        }
        dp[i] = make([]int, 2)
        if dp[i-1][0] < dp[i-1][1] + x - fee {
            dp[i][0] = dp[i-1][1] + x - fee
        }else {
            dp[i][0] = dp[i-1][0]
        }
        if dp[i-1][1] < dp[i-1][0] - x {
            dp[i][1] = dp[i-1][0] - x 
        }else {
            dp[i][1] = dp[i-1][1]
        }
    }
    return dp[len(prices)-1][0]
}

---

968. 监控二叉树

每个节点有三种状态：有摄像头，被监控，没被监控

应该从底层出发，并且底层节点都不能被放置摄像头。

这道题也可以让我学习下go语言的指针和结构

var ret int
func minCameraCover(root *TreeNode) int {
    x := find(root)
    if x == 0 {
        ret ++
    }
    return ret
}
//0没被监控
//1被监控
//2放有摄像头
func find(root *TreeNode) int {
    if root == nil {
        return 1;
    }
    left := find(root.Left)
    right := find(root.Right)
    if left == 0 || right == 0 {
        ret ++
        return 2
    }
    if left == 1 && right == 1 {
        return 0
    }
    if left == 2 || right == 2 {
        return 1
    }
    return -1
}