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 是链表中所有结点的值的一个子集.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

根据官方题解可知，利用set先把G的数据保存到一个集合中，然后遍历链表，判断所在的结点的val是否存在集合并且判断下一个结点的炸了是否不再集合中或下一个结点指向NULL，这样的话就构成不同的component了。

C++代码:

/**

 * Definition for singly-linked list.

 * struct ListNode {

 *     int val;

 *     ListNode *next;

 *     ListNode(int x) : val(x), next(NULL) {}

 * };

 */

class Solution {

public:

    int numComponents(ListNode* head, vector<int>& G) {

        set<int> s;

        for(int x:G) s.insert(x);

        ListNode *cur = head;

        int ans = ;

        while(cur){

            if(s.count(cur->val) && (cur->next == NULL || !s.count(cur->next->val)))

                ans++;

            cur = cur->next;

        }

        return ans;

    }

};