[Swift]LeetCode1042. 不邻接植花 | Flower Planting With No Adjacent

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10852070.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

You have N gardens, labelled 1 to N.  In each garden, you want to plant one of 4 types of flowers.

paths[i] = [x, y] describes the existence of a bidirectional path from garden x to garden y.

Also, there is no garden that has more than 3 paths coming into or leaving it.

Your task is to choose a flower type for each garden such that, for any two gardens connected by a path, they have different types of flowers.

Return any such a choice as an array answer, where answer[i] is the type of flower planted in the (i+1)-th garden.  The flower types are denoted 1, 2, 3, or 4.  It is guaranteed an answer exists.

Example 1:

Input: N = 3, paths = [[1,2],[2,3],[3,1]]
Output: [1,2,3]

Example 2:

Input: N = 4, paths = [[1,2],[3,4]]
Output: [1,2,1,2]

Example 3:

Input: N = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
Output: [1,2,3,4]

Note:

• 1 <= N <= 10000
• 0 <= paths.size <= 20000
• No garden has 4 or more paths coming into or leaving it.
• It is guaranteed an answer exists.

---

有 N 个花园，按从 1 到 N 标记。在每个花园中，你打算种下四种花之一。

paths[i] = [x, y] 描述了花园 x 到花园 y 的双向路径。

另外，没有花园有 3 条以上的路径可以进入或者离开。

你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。

以数组形式返回选择的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用  1, 2, 3, 4 表示。保证存在答案。

示例 1：

输入：N = 3, paths = [[1,2],[2,3],[3,1]]
输出：[1,2,3]

示例 2：

输入：N = 4, paths = [[1,2],[3,4]]
输出：[1,2,1,2]

示例 3：

输入：N = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
输出：[1,2,3,4]

提示：

• 1 <= N <= 10000
• 0 <= paths.size <= 20000
• 不存在花园有 4 条或者更多路径可以进入或离开。
• 保证存在答案。

---

Runtime: 528 ms

Memory Usage: 22.3 MB

class Solution {
    func gardenNoAdj(_ N: Int, _ paths: [[Int]]) -> [Int] {
        var G:[[Int]] = [[Int]](repeating: [Int](), count: N)
        for v in paths
        {
            let x:Int = v[0] - 1
            let y:Int = v[1] - 1
            G[x].append(y)
            G[y].append(x)
        }
        var res:[Int] = [Int](repeating: 0, count: N)
        for v in 0..<N
        {
            var ss:Set<Int> = Set<Int>()
            for u in G[v]
            {
                ss.insert(res[u])
            }
            res[v] = 1
            while(ss.contains(res[v]))
            {
                res[v] += 1
            }
        }
        return res
    }
}

---

624ms

class Solution {
    func gardenNoAdj(_ N: Int, _ paths: [[Int]]) -> [Int] {
        var g = [Int: Set<Int>]()
        for p in paths {
            g[p[0]-1, default: Set<Int>()].insert(p[1]-1)
            g[p[1]-1, default: Set<Int>()].insert(p[0]-1)
        }
        guard g.count > 1 else { return [Int](repeating: 1, count: N) }
        var ans = [Int](repeating: -1, count: N)
        for c in 0..<N {
            if ans[c] == -1 {
                ans[c] = 1
                recursive(g, c, &ans)
            }
        }
        
        for i in 0..<ans.endIndex {
            if ans[i] == -1 {
                ans[i] = 1
            }
        }
        
        return ans
    }
    
    private func recursive(_ paths: [Int: Set<Int>], _ cur: Int, _ ans: inout [Int]) {
        guard paths[cur] != nil else { return }
        for dest in paths[cur]!.sorted(by: {paths[$0]?.count ?? 0 > paths[$1]?.count ?? 0}) {
            // print("cur: (cur), dest: (dest), color: (ans)")
            if ans[dest] == -1 {
                ans[dest] = selectColor(paths, dest, ans)
            }
        }
    }
    
    private func selectColor(_ paths: [Int: Set<Int>], _ g: Int, _ ans: [Int]) -> Int {
        var colors = Set<Int>([1, 2, 3, 4])
        for s in paths[g]! {
            if ans[s] != -1 {
                colors.remove(ans[s])
            }
        }
        return colors.first!
    }
}

---

708ms

class Solution {
    func gardenNoAdj(_ N: Int, _ paths: [[Int]]) -> [Int] {
        var edges = [Int: [Int]]()
        
        for path in paths {
            let a = path[0]
            let b = path[1]
            
            if edges[a] == nil {
                edges[a] = [b]
            } else {
                edges[a]?.append(b)
            }
            
            if edges[b] == nil {
                edges[b] = [a]
            } else {
                edges[b]?.append(a)
            }
        }
        
        var result = [Int](repeating: 0, count: N + 1)
        var availableColors = Array(repeating: Set([1, 2, 3, 4]), count: N + 1)
        var unvisited = Set(Array(1...N))
        
        while let first = unvisited.first {
            var queue = Set([first])
            while !queue.isEmpty {
                var nextQueue = Set<Int>()
                for node in queue {
                    let color = availableColors[node].first!
                    result[node] = color
                    unvisited.remove(node)
                    nextQueue.remove(node)
                    for neighbor in edges[node, default: []] {
                        availableColors[neighbor].remove(color)
                        guard unvisited.contains(neighbor) else { continue }
                        nextQueue.insert(neighbor)
                    }
                }
                queue = nextQueue
            }
        }
        
        result.removeFirst()
        
        return result
    }
}