2 1 2
4
1000 3 4 3 5
1001 2 1 2
114514 3 1 2 3
1919810 1 1

3
1001 114514 1919810

#include <iostream>
#include <set>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    // 读取节点A的端口数量及其端口ID集合
    int m;
    cin >> m;
    set<int> aBlocks;
    for (int i = 0; i < m; i++) {
        int portId;
        cin >> portId;
        aBlocks.insert(portId);
    }

    // 读取其他节点数量
    int n;
    cin >> n;
    vector<unsigned long long> connectedNodes;

    // 处理每个节点的信息
    for (int i = 0; i < n; i++) {
        unsigned long long name;
        int t;
        cin >> name >> t;
        bool isConnected = false;

        // 检查节点的每个端口ID是否与节点A连通
        for (int j = 0; j < t; j++) {
            int portId;
            cin >> portId;
            if (aBlocks.count(portId)) {
                isConnected = true;
            }
        }

        // 如果连通，将节点名称加入连通节点列表
        if (isConnected) {
            connectedNodes.push_back(name);
        }
    }

    // 对连通节点名称进行排序并输出
    sort(connectedNodes.begin(), connectedNodes.end());
    cout << connectedNodes.size() << endl;
    for (unsigned long long node : connectedNodes) {
        cout << node << " ";
    }
    cout << endl;

    return 0;
}

# 读取节点A的信息
m, *a_ports = map(int, input().split())
a_blocks = set(a_ports)  # 使用集合存储节点A的端口ID

# 读取其他节点的数量
n = int(input())
connected_nodes = []

# 遍历每个节点
for _ in range(n):
    data = list(map(int, input().split()))
    name, t, ports = data[0], data[1], data[2:]
    
    # 检查当前节点是否与节点A连通
    if a_blocks.intersection(ports):
        connected_nodes.append(name)

# 输出结果
connected_nodes.sort()
print(len(connected_nodes))
print(" ".join(map(str, connected_nodes)))

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取节点A的端口数量
        int m = scanner.nextInt();
        
        // 使用Set存储节点A的端口ID，以便快速查找
        Set<Long> set = new HashSet<>();
        for (int i = 0; i < m; i++) {
            set.add(scanner.nextLong());
        }
        
        // 读取其他节点的数量
        int n = scanner.nextInt();
        
        // 使用 TreeSet 存储结果节点名称，自动排序
        TreeSet<Long> res = new TreeSet<>();
        
        // 处理输入的其他节点
        scanner.nextLine(); // 清空当前行
        for (int i = 0; i < n; i++) {
            String[] str = scanner.nextLine().split(" ");
            
            // 读取节点的名称
            Long node = Long.parseLong(str[0]);
            boolean flag = false; // 用于标识是否连通

            // 从端口ID开始遍历，检查是否有与节点A连通的端口
            for (int j = 2; j < str.length; j++) {
                if (set.contains(Long.parseLong(str[j]))) {
                    // 如果有连通的端口，记录该节点名称，并设置连通标志
                    flag = true;
                    break;
                }
            }

            // 如果节点与A连通，将其名称加入结果集合
            if (flag) {
                res.add(node);
            }
        }

        // 输出连通节点的数量
        System.out.println(res.size());
        
        // 输出连通节点的名称
        int sum = 1;
        for (long node : res) {
            if (sum == res.size()) {
                System.out.print(node);
            } else {
                System.out.print(node + " ");
            }
            sum++;
        }
    }
}