You are given the head of a linked list containing unique integer values and an integer array nums that is a subset of the linked list values.

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

&nbsp;
Example 1:

Input: head = [0,1,2,3], nums = [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], nums = [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.


&nbsp;
Constraints:


	The number of nodes in the linked list is n.
	1 &lt;= n &lt;= 104
	0 &lt;= Node.val &lt; n
	All the values Node.val are unique.
	1 &lt;= nums.length &lt;= n
	0 &lt;= nums[i] &lt; n
	All the values of nums are unique.


class Solution:
    def numComponents(self, head: Optional[ListNode], nums: List[int]) -> int:
        d,count={},0
        for num in nums:
            d[num] = 0

        while head:
            if head.val in d:
                head = head.next
                while head and head.val in d:
                    head = head.next
                count += 1
            else:
                head = head.next
        return count
class Solution {
    public int numComponents(ListNode head, int[] nums) {
        int count=0;
        HashSet<Integer> set=new HashSet();
        for(int i=0;i<nums.length;i++)
        {
            set.add(nums[i]);
        }
        while(head!=null)
        {  
            if(set.contains(head.val))
            {
                while(head.next!=null&&set.contains(head.next.val))
                {
                    head=head.next;

                }
                count++;
            }
            
           
                head=head.next;
            
            
        }
        return count;
    }
}
class Solution {
public:
    int numComponents(ListNode* head, vector<int>& nums)
    {
        unordered_set<int> s;
        for(auto &x:nums)
            s.insert(x);
        int count=0;
        while(head!=NULL)
        {
            if(s.find(head->val)!=s.end()) count++;
            while(head!=NULL && s.find(head->val)!=s.end())
            {
                head=head->next;
            }
            if(head!=NULL)
            head=head->next;
        }
        return count;
    }
};
var numComponents = function(head, nums) {
    let broken = true, count = 0;

    while (head) {
        if (nums.includes(head.val) && broken) {
            count++;
            broken = false;
        }
        else if (!nums.includes(head.val)) {
            broken = true;
        }

        // reset head as next
        head = head.next
    }

    // result
    return count;
};
Linked List Components