[Swift]LeetCode817. 链表组件 | Linked List Components

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

We are given head, the head node of a linked list containing unique integer values.

We are also given the list G, a subset of the values in the linked list.

Return the number of connected components in G, where two values are connected if they appear consecutively in the linked list.

Example 1:

Input: 
head: 0->1->2->3
G = [0, 1, 3]
Output: 2
Explanation: 
0 and 1 are connected, so [0, 1] and [3] are the two connected components.

Example 2:

Input: 
head: 0->1->2->3->4
G = [0, 3, 1, 4]
Output: 2
Explanation: 
0 and 1 are connected, 3 and 4 are connected, so [0, 1] and [3, 4] are the two connected components.

Note:

• If N is the length of the linked list given by head, 1 <= N <= 10000.
• The value of each node in the linked list will be in the range [0, N - 1].
• 1 <= G.length <= 10000.
• G is a subset of all values in the linked list.

---

给定一个链表（链表结点包含一个整型值）的头结点 head。

同时给定列表 G，该列表是上述链表中整型值的一个子集。

返回列表 G 中组件的个数，这里对组件的定义为：链表中一段最长连续结点的值（该值必须在列表 G 中）构成的集合。

示例 1：

输入: 
head: 0->1->2->3
G = [0, 1, 3]
输出: 2
解释: 
链表中,0 和 1 是相连接的，且 G 中不包含 2，所以 [0, 1] 是 G 的一个组件，同理 [3] 也是一个组件，故返回 2。

示例 2：

输入: 
head: 0->1->2->3->4
G = [0, 3, 1, 4]
输出: 2
解释: 
链表中，0 和 1 是相连接的，3 和 4 是相连接的，所以 [0, 1] 和 [3, 4] 是两个组件，故返回 2。

注意:

• 如果 N 是给定链表 head 的长度，1 <= N <= 10000。
• 链表中每个结点的值所在范围为 [0, N - 1]。
• 1 <= G.length <= 10000
• G 是链表中所有结点的值的一个子集.

---

148ms

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func numComponents(_ head: ListNode?, _ G: [Int]) -> Int {

        let numbers = Set(G)
        var node = head
        var count = 0
        var isSameComponent = false
        while let current = node {
            if numbers.contains(current.val) {
                if !isSameComponent {
                    isSameComponent = true
                    count += 1
                }
            } else {
                isSameComponent = false
            }
            node = node?.next
        }
        
        return count
    }
}

---

Runtime: 156 ms

Memory Usage: 19.5 MB

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
func numComponents(_ head: ListNode?, _ G: [Int]) -> Int {
    guard head != nil && G.count > 0 else {
        return 0
    }
    let setG: Set = Set(G)
    
    var result = 1
    var pre = head
    var l1 = head?.next
    while l1 != nil {
        var flag = false
        if setG.contains(pre!.val) && !setG.contains(l1!.val){
            var l2 = l1?.next
            while l2 != nil{
                if setG.contains(l2!.val){
                    pre = l2
                    l1 = l2?.next
                    result += 1
                    flag = true
                    break
                }
                l2 = l2?.next
            }
        }
        if !flag{
            pre = l1
            l1 = l1?.next
        }
    }
    return result
  }
}

---

Runtime: 160 ms

Memory Usage: 19.8 MB

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init(_ val: Int) {
 *         self.val = val
 *         self.next = nil
 *     }
 * }
 */
class Solution {
    func numComponents(_ head: ListNode?, _ G: [Int]) -> Int {
        var head = head
        var res:Int = 0
        var nodeSet:Set<Int> = Set<Int>(G)
        while (head != nil)
        {
            if nodeSet.contains(head!.val) && (head?.next == nil || !nodeSet.contains(head!.next!.val))
            {
                res += 1
            }
            head = head?.next
        }
        return res
    }
}

---

176ms

class Solution {
    func numComponents(_ head: ListNode?, _ g: [Int]) -> Int {
        let gSet = Set(g)
        
        var count = 0
        var connected = false
        var possibleNode = head
        
        while let node = possibleNode {
            switch (connected, gSet.contains(node.val)) {
                case (true, false):
                    connected = false
                case (false, true):
                    connected = true
                    count += 1
                default:
                    ( /* Do nothing. */ ) 
            }
            possibleNode = node.next
        }
        
        return count
    }
}

---

184ms

class Solution {
    func numComponents(_ head: ListNode?, _ G: [Int]) -> Int {
        var count = 0
        var set = Set(G)
        var node = head
        var hasCut = false
        while node != nil {
            if !set.contains(node!.val) {
                hasCut = true
            } else {
                if hasCut {
                    count += 1
                    hasCut = false
                }
                if count == 0 { count = 1 }
            }
            node = node?.next
        }
        return count
    }
}