算法 - 贪心05（Swift版本）

题目1：56.合并区间

讲解
leetcode

// @lc code=start
class Solution {
    func merge(_ intervals: [[Int]]) -> [[Int]] {
        if intervals.count == 1 { return intervals }
        var intervals = intervals.sorted { $0[0] < $1[0] }
        var res = [[Int]]()
        var left = intervals[0][0], right = intervals[0][1]
        for i in 1..<intervals.count {
            // 不重叠
            if intervals[i][0] > intervals[i - 1][1] {
                res.append([left, right])
                left = intervals[i][0]
                right = intervals[i][1]
            } else {
                right = max(intervals[i][1], intervals[i - 1][1])
                // 重点在这里， 这里重叠边界 需要取较大值
                intervals[i][1] = max(intervals[i - 1][1], intervals[i][1])
            }
        }
        res.append([left, right])
        return res
    }
}
// @lc code=end

题目2：738.单调递增的数字

讲解
leetcode
如果碰到数字非递增，那么高位数字-1，低位数字变9。 遍历顺序，从后向前。
数字的处理就转为字符串数组来处理。

注意下数字和字符串的转化。

// @lc code=start
class Solution {
    func monotoneIncreasingDigits(_ n: Int) -> Int {
        var nums = Array(String(n))
        var tag = nums.count
        for i in (1..<nums.count).reversed() {
            if nums[i] < nums[i - 1] {
                tag = i - 1
                nums[i - 1] = Character(UnicodeScalar(nums[i - 1].asciiValue! - 1))
            }
        }
        if tag == nums.count { return n }
        for i in (tag+1)..<nums.count {
            nums[i] = "9"
        }
        return Int(String(nums))!
    }
}
// @lc code=end

题目3：968.监控二叉树

讲解
leetcode

状态备注： 0：无覆盖 1：有摄像头 2：有覆盖
另外下面判断逻辑的顺序不能变。
这两个逻辑有覆盖，左或者右 无覆盖的优先级更高

if left == 0 || right == 0
if left == 1 || right == 1

// @lc code=start
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     public var val: Int
 *     public var left: TreeNode?
 *     public var right: TreeNode?
 *     public init() { self.val = 0; self.left = nil; self.right = nil; }
 *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
 *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
 *         self.val = val
 *         self.left = left
 *         self.right = right
 *     }
 * }
 */
class Solution {
    func minCameraCover(_ root: TreeNode?) -> Int {
        var result = 0
        func recursive(_ root: TreeNode?) -> Int {
            // 空节点认为有覆盖，目的为了叶子节点不放摄像头
            guard let root else { return 2 }
            var left = recursive(root.left)
            var right = recursive(root.right)
            // 如果左右都有覆盖，那么父节点为无覆盖
            if left == 2, right == 2 { return 0 }

            // 如果左或者右 有一个为无覆盖，那么父节点为摄像头
            if left == 0 || right == 0 { 
                result += 1
                return 1 
            }

            // 左或者右 有一个摄像头，那么父节点为有覆盖
            if left == 1 || right == 1 { return 2 }

            // 不会走到这里，全面已经枚举全了
            return -1
        }
        if recursive(root) == 0 {
            result += 1
        }
        return result        
    }
}
// @lc code=end