三星研究院机试（无向图）

题目描述：
给一无向图中各个节点绘色，一共只有两种颜色，使其满足相邻节点颜色不同，并输出其中一种颜色的节点个数及序号；如果不满足，则输出-1。

示例：

第一行输入节点个数V和边数E，第二行输入E条边（每条边对应的两个节点），例如：

7 9

1 2 1 4 2 3 3 4 2 5 4 5 2 6 5 7 6 7

思路：用两种颜色将图中的所有顶点着色，且使得任意一条边的两个端点的颜色都不相同，等同于二分图的判定问题。

有向图、无向图，一般用邻接表或者邻接矩阵实现。

•        List<Integer>[] graph;  // 邻接表
•        boolean[][] matrix;   // 邻接矩阵

这里的无向图，需要在x的邻居列表里添加y，同时在y的邻居列表里添加x。

public class Solution {

    public static int V;
    public static int E;
    public static boolean ok = true;
    public static boolean[] color;  // 记录图中节点的颜色，false 和 true 代表两种不同颜色
    public static boolean[] visited;  // 记录图中节点是否被访问过


    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int T;
        T = sc.nextInt();
        for(int t = 1; t <= T; t++) {

            V = sc.nextInt();
            E = sc.nextInt();

            int[] arr = new int[E*2];

            for (int i = 0; i < E*2; i++) {
                arr[i] = sc.nextInt();
            }
            color = new boolean[V + 1];
            Arrays.fill(color, false);
            visited = new boolean[V + 1];
            Arrays.fill(visited, false);

            LinkedList<Integer>[] graph = new LinkedList[V + 1]; // 邻接表
            // 初始化数组中的每个链表
            for (int i = 0; i <= V; i++) {
                graph[i] = new LinkedList<>();
            }

            for (int i = 0; i < arr.length; i += 2) { 
                int x = arr[i];  
                int y = arr[i + 1];  
                graph[x].add(y);
                graph[y].add(x);

            }

            for (int i = 1; i <= V; i++) { // 遍历每个顶点
                if (!visited[i]) {
                    bfs(graph, i);
                }
            }
            
            StringBuilder sb = new StringBuilder();
            if (ok == false) {
                sb.append("#").append(t).append(" ").append("-1");
            } else {
                StringBuilder res = new StringBuilder();
                int num = 0;
                for (int i = 1; i < color.length; i++) {
                    if (color[i] == false) {
                        res.append(i).append(" ");
                        num++;
                    }
                }
                sb.append("#").append(t).append(" ").append(num).append(" ").append(res);
            }

            System.out.println(sb);
        }
        sc.close();
    }

    private static void bfs(LinkedList<Integer>[] graph, int start) {
        
        Queue<Integer> q = new LinkedList<>();
        visited[start] = true;
        q.offer(start);

        while (!q.isEmpty() && ok) {
            int cur = q.poll();
            // 从节点 cur 向所有相邻节点扩散
            for (int w : graph[cur]) {
                if (!visited[w]) {
                    // 相邻节点 w 没有被访问过
                    // 那么应该给节点 w 涂上和节点 v 不同的颜色
                    color[w] = !color[cur];
                    // 标记 w 节点，并放入队列
                    visited[w] = true;
                    q.offer(w);
                } else {
                    // 相邻节点 w 已经被访问过
                    // 根据 v 和 w 的颜色判断是否是二分图
                    if (color[w] == color[cur]) {
                        // 若相同，则此图不是二分图
                        ok = false;
                    }
                }
            }

        }

    }
}