[Swift]LeetCode785. 判断二分图 | Is Graph Bipartite?

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given an undirected graph, return true if and only if it is bipartite.

Recall that a graph is bipartite if we can split it's set of nodes into two independent subsets A and B such that every edge in the graph has one node in A and another node in B.

The graph is given in the following form: graph[i] is a list of indexes j for which the edge between nodes i and j exists.  Each node is an integer between 0 and graph.length - 1.  There are no self edges or parallel edges: graph[i] does not contain i, and it doesn't contain any element twice.

Example 1:
Input: [[1,3], [0,2], [1,3], [0,2]]
Output: true
Explanation: 
The graph looks like this:
0----1
|    |
|    |
3----2
We can divide the vertices into two groups: {0, 2} and {1, 3}.

Example 2:
Input: [[1,2,3], [0,2], [0,1,3], [0,2]]
Output: false
Explanation: 
The graph looks like this:
0----1
| \  |
|  \ |
3----2
We cannot find a way to divide the set of nodes into two independent subsets. 

Note:

• graph will have length in range [1, 100].
• graph[i] will contain integers in range [0, graph.length - 1].
• graph[i] will not contain i or duplicate values.
• The graph is undirected: if any element j is in graph[i], then i will be in graph[j].

---

给定一个无向图graph，当这个图为二分图时返回true。

如果我们能将一个图的节点集合分割成两个独立的子集A和B，并使图中的每一条边的两个节点一个来自A集合，一个来自B集合，我们就将这个图称为二分图。

graph将会以邻接表方式给出，graph[i]表示图中与节点i相连的所有节点。每个节点都是一个在0到graph.length-1之间的整数。这图中没有自环和平行边： graph[i] 中不存在i，并且graph[i]中没有重复的值。

示例 1:
输入: [[1,3], [0,2], [1,3], [0,2]]
输出: true
解释: 
无向图如下:
0----1
|    |
|    |
3----2
我们可以将节点分成两组: {0, 2} 和 {1, 3}。

示例 2:
输入: [[1,2,3], [0,2], [0,1,3], [0,2]]
输出: false
解释: 
无向图如下:
0----1
| \  |
|  \ |
3----2
我们不能将节点分割成两个独立的子集。

注意:

• graph 的长度范围为 [1, 100]。
• graph[i] 中的元素的范围为 [0, graph.length - 1]。
• graph[i] 不会包含 i 或者有重复的值。
• 图是无向的: 如果j 在 graph[i]里边, 那么 i 也会在 graph[j]里边。

---

Runtime: 176 ms

Memory Usage: 19.2 MB

class Solution {
    func isBipartite(_ graph: [[Int]]) -> Bool {
        var colors:[Int] = [Int](repeating:0,count:graph.count)
        for i in 0..<graph.count
        {
            if colors[i] != 0 {continue}
            colors[i] = 1
            var q:[Int] = [i]
            while(!q.isEmpty)
            {
                var t:Int = q.first!
                q.removeFirst()
                for a in graph[t]
                {
                    if colors[a] == colors[t] {return false}
                    if colors[a] == 0
                    {
                        colors[a] = -1 * colors[t]
                        q.append(a)
                    }
                }                
            }
        }
        return true
    }
}

---

208ms

class Solution {
    func isBipartite(_ graph: [[Int]]) -> Bool {
        let V = graph.count
        var colors = Array(repeating: -1, count: V)
        for i in 0 ..< V {
            if colors[i] == -1 && !validColor(&colors, 0, graph, i) {
                return false
            }
        }
        return true
    }
    
    func validColor(_ colors: inout [Int], _ color: Int, _ graph: [[Int]], _ vertex: Int) -> Bool {
        if colors[vertex] != -1 {
            return colors[vertex] == color
        }
        colors[vertex] = color
        for neighbor in graph[vertex] {
            if !validColor(&colors, 1 - color, graph, neighbor) {
                return false
            }
        }
        return true
    }
}

---

212ms

class Solution {
    func isBipartite(_ graph: [[Int]]) -> Bool {
    var color = Array<Color>(repeating: .unknown, count: graph.count)
    
    for i in 0..<graph.count {
        guard color[i] == .unknown else { continue }
        if !dfs(i: i, color: &color, graph: graph, paint: .red) { return false }
    }
        return true
    }
    func dfs(i: Int, color: inout [Color], graph: [[Int]], paint: Color) -> Bool {
        guard color[i] == .unknown else {
            return color[i] == paint
        }
        color[i] = paint
        for neighbour in graph[i] {
            if !dfs(i: neighbour, color: &color, graph: graph, paint: paint.opposite)
            {
                return false 
            }
    }
    return true
  }
}

enum Color {
    case red
    case blue
    case unknown
    
    var opposite: Color {
        switch self {
        case .red:
            return .blue
        case .blue:
            return .red
        case .unknown:
            return .unknown
        }
    }
}

---

220ms

class Solution {
    func isBipartite(_ graph: [[Int]]) -> Bool {
        var visited: Set<Int> = []
        
        for seed in 0..<graph.count {
            if visited.contains(seed) { continue }
            
            var oddSet: Set<Int> = []
            var evenSet: Set<Int> = []
            
            var queue = [seed]
            var level = 0
            
            while !queue.isEmpty {
                var nextLevel = [Int]()
                
                for vertex in queue {
                    visited.insert(vertex)
                    if level % 2 == 0 {      
                        if oddSet.contains(vertex) {
                            return false
                        }

                        if !evenSet.contains(vertex) {
                            nextLevel += graph[vertex]
                            evenSet.insert(vertex)
                        }
                    } else {
                        if evenSet.contains(vertex) {
                            return false
                        }

                        if !oddSet.contains(vertex) {
                            nextLevel += graph[vertex]
                            oddSet.insert(vertex)
                        } 
                    }
                }
                queue = nextLevel
                level += 1
            }            
        }        
        return true
    }
}

---

224ms

class Solution {
    enum NodeStatus {
        case red, black, undefined
        func negate() -> NodeStatus {
            switch self {
                case .red:
                    return .black
                case .black:
                    return .red
                case .undefined:
                    return .undefined
            }
        }
    }
    
    var nodeStatus: [Int: NodeStatus] = [:]
    var graph: [[Int]] = []
    var nodeCount = 0
    
    func status(_ node: Int) -> NodeStatus {
        return nodeStatus[node] ?? .undefined
    }
    
    func findConflict(byFlooding nodes: [Int]) -> Bool {
        var nextNodes = nodes
        while nextNodes.count > 0 {
            let currentNodes = nextNodes
            nextNodes = [Int]()
            for node in currentNodes {
                for adjacent in graph[node] {
                    let currentStatus = status(node)
                    let statusToColor = currentStatus.negate()
                    if nodeStatus[adjacent] == .undefined {
                        nodeStatus[adjacent] = statusToColor
                        nextNodes.append(adjacent)
                    } else if nodeStatus[adjacent] == currentStatus {
                        return true
                    }
                }
            }
        }
        return false
    }
    
    func undefinedNode() -> Int? {
        for i in 0..<nodeCount {
            if status(i) == .undefined {
                return i
            }
        }
        return nil
    }
    
    func setup(_ graph: [[Int]]) {
        self.graph = graph
        nodeCount = graph.count
        for i in 0..<graph.count {
            nodeStatus[i] = .undefined
        }
    }
               
    func isBipartite(_ graph: [[Int]]) -> Bool {
        setup(graph)
        while let node = undefinedNode() {
            nodeStatus[node] = .red
            let hasConflict = findConflict(byFlooding: [node])
            if hasConflict {
                return false
            }
        }
        
        return true
    }
}

---

228ms

class Solution {
    func isBipartite(_ graph: [[Int]]) -> Bool {
        guard graph.count > 0 else {
            return false
        }
        let black = 0
        let white = 1
        var visited = [Int:Int]()
        
        func bfs(node:Int, pColor:Int) -> Bool {
            if let color = visited[node] {
                return color != pColor
            }
            
            visited[node] = pColor == white ? black : white
            
            let neighb = graph[node]            
            for n in neighb {
                if !bfs(node:n, pColor:visited[node]!) {
                    return false 
                }
            }
            return true
        }
        
        for i in 0..<graph.count {
            if visited[i] == nil {
                if !bfs(node:i, pColor:white) {
                    return false
                }
            }    
        }
        
        return true
    }
}