笔试时间：2023年8月23日 秋招

第一题

题目：获取连通的相邻节点列表

在网元内，存在了N个转发节点，每个转发节点有自己唯一的标识TB且每个节点有M个端口，节点间通过端口进行报文通讯。出于业务隔离的需求，服务器内的端口被划分为多个通讯平面(用VLAN隔离，每个VLAN都有一个VLAN ID作为标识)：

1、如果两个端口的VLAN ID相同，则说明这两个端口处于同个VLAN，且处于连通状态;

2、如果两个端口的VLANID不同，则说明这两个端口处于不同VLAN，彼此不连通;

现给出节点A的端口数及其各端口所属的VLAN ID，以及节点A相邻的其他节点和端口信息。要求获取与节点A处于连通状态的所有相邻节点的TB列表（按TB从小到大顺序输出）

输入描述

第1行:M VLAN_ID_1...VLAN_ID_m

数据间有空格隔开，分别表示:节点A有M个端口，各个端口所属的VLAN_ID，即后面VLAN_ID_m表示第m个端口的VLAN ID。

其中，网元内节点的端口数量M的取值范围为[1,4];端口划分VLAN ID的取值范围为[1,4];

第2行:N

表示与节点A相邻的其他节点有N个，N的取值范围为[0,4000)

第3行开始，将有N行数据，分别描述与节点A相邻的节点的TB和端口信息

输入格式为:TBx Mx VLAN_ID_xx...VLAN_ID_xm

数据间有空格隔开，分别表示: 节点x的TBx，有Mx个端口，各个端口所属的VLAN_ID，即后面VLAN_ID_xm表示第m个端口的VLAN ID。

其中，网元内节点TB的取值范围为(0,4294967295);

输出描述

第1行:N

表示与节点A连通的相邻节点个数，如 N为0，则无需在输出其他信息

第2行:TB_1...TB_n

数据间有空格隔开，分别表示:与节点A连通的相邻节点的TB，个数为N，按从小到大的顺序输出。

样例输入

1 1

3

1024 2 1 2

1023 1 1

1025 3 2 2 3

样例输出

2

1023 1024

解释：TB为1025的节点，其端口与节点A的端口均不在一个VLAN内，故与节点A不连通

TB为1024和1023的节点，均有端口与节点A的端口在VLAN ID为1的VLAN内，故与节点A连通

参考题解

哈希表

C++:

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

using namespace std;

int main() {
    set<long long> s;
    int M;
    cin >> M;
    
    for (int i = 0; i < M; i++) {
        long long a;
        cin >> a;
        s.insert(a);
    }

    int N;
    cin >> N;
    vector<long long> nodes;

    for (int i = 0; i < N; i++) {
        long long TB, Mx;
        cin >> TB >> Mx;
        bool flag = false;

        for (long long l = 0; l < Mx; l++) {
            long long VLAND;
            cin >> VLAND;

            if (s.count(VLAND) > 0) {
                flag = true;
            }
        }

        if (flag) {
            nodes.push_back(TB);
        }
    }

    sort(nodes.begin(), nodes.end());

    if (!nodes.empty()) {
        cout << nodes.size() << endl;
        for (long long re : nodes) {
            cout << re << " ";
        }
    } else {
        cout << 0 << endl;
    }

    return 0;
}

Java：

import java.io.*;
import java.util.*;

public class Main{
    static PrintWriter print = new PrintWriter(new OutputStreamWriter(System.out));
    static FastScanner in = new FastScanner(System.in);

    public static void main(String[] args) {
        Set<Long> set = new HashSet<>();
        int M = in.nextInt();
        for (int i = 0; i < M; i++) {
            long a = in.nextLong();
            set.add(a);
        }
        int N = sc.nextInt();
        List<Long> nodes = new ArrayList<>();
        for (int i = 0; i < N; i++) {

            long TB = in.nextLong();
            long Mx = in.nextLong();
            boolean flag = false;
            for (long l = 0; l < Mx; l++) {
                long VLAND = in.nextLong();
                if (set.contains(VLAND)) {
                    flag = true;
                }
            }
            if (flag) nodes.add(TB);

        }
        Collections.sort(nodes);

        if (nodes.size() > 0) {
            print.println(nodes.size());
            for (Long re : nodes) {
                print.print(re + " ");
            }
        }
        else print.println(0);
        print.flush();

    }

    private static  class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        public FastScanner(InputStream stream){
            br =  new BufferedReader(new InputStreamReader(stream), 32768);
            st = null;
        }
        String next() {
            while (st == null ||  !st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble(){return Double.parseDouble(next());}
    }

}

Python：

M = int(input())
s = set(map(int, input().split()))
N = int(input())
nodes = []

for i in range(N):
    TB, Mx = map(int, input().split())
    flag = False

    for _ in range(Mx):
        VLAND = int(input())
        if VLAND in s:
            flag = True

    if flag:
        nodes.append(TB)

nodes.sort()

if nodes:
    print(len(nodes))
    print(*nodes)
else:
    pr