1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import java.io.*;
import java.util.*;

public class mis {

    private static Integer[] vertex;
    private static HashMap<Integer, Set<Integer>> graph;
    private static Set<Integer> ok;
    private static LinkedList<Integer> toDelete;
    private static int n, m, d;

    private static void delete(Integer vert) {
        for (int i : graph.get(vert)) {
            graph.get(i).remove(vert);
            if (graph.get(i).size() < d) {
                toDelete.add(vertex[i]);
                ok.remove(vertex[i]);
            }
        }
    }

    private static void doMagic() {
        for (int i = 1; i <=n; i++) {
            if (graph.get(i).size() < d) {
                toDelete.add(vertex[i]);
            } else {
                ok.add(vertex[i]);
            }
        }

        while (!toDelete.isEmpty()) {
            delete(toDelete.removeFirst());
        }


        if (ok.isEmpty()) {
            System.out.println("NIE");
            return;
        }

        Set<Integer> biggestSet = Collections.emptySet(), currentSet;

        while (!ok.isEmpty()) {
            Integer curr = ok.iterator().next();
            ok.remove(curr);
            currentSet = getSubset(curr, new HashSet<Integer>(){{add(curr);}});
            if (currentSet.size() > biggestSet.size()) {
                biggestSet = currentSet;
            }
        }

        System.out.println(biggestSet.size());
        Integer[] arr = new Integer[biggestSet.size()];
        biggestSet.toArray(arr);
        Arrays.sort(arr);
        StringBuilder sb = new StringBuilder();
        for (Integer i : arr) {
            sb.append(i).append(" ");
        }
        System.out.print(sb.toString());
    }

    private static HashSet<Integer> getSubset(Integer vertex, HashSet<Integer> hs){
        if (graph.get(vertex).isEmpty())
            return hs;

        hs.addAll(graph.get(vertex));
        Set<Integer> tmp = graph.get(vertex);
        ok.removeAll(tmp);
        graph.put(vertex, Collections.emptySet());
        for (Integer i : tmp) {
            graph.get(i).remove(vertex);
        }

        for (Integer i : tmp) {
            getSubset(i, hs);
        }

        return hs;
    }


    private static void readInput(String[] args) {
        BufferedReader br;
        try {
            br = new BufferedReader(new FileReader(args[0]));
        } catch (FileNotFoundException | IndexOutOfBoundsException e) {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        try {
            StringTokenizer st = new StringTokenizer(br.readLine());
            n = Integer.parseInt(st.nextToken());
            m = Integer.parseInt(st.nextToken());
            d = Integer.parseInt(st.nextToken());

            vertex = new Integer[n+1];
            graph = new HashMap<>(n);
            toDelete = new LinkedList<>();
            ok = new HashSet<>(n);
            for (int i = 1; i <= n; i++) {
                vertex[i] = i;
                graph.put(vertex[i], new HashSet<>(n/m));
            }

            int first, second;
            for (int i = 0; i < m; i++) {
                st = new StringTokenizer(br.readLine());
                first = Integer.parseInt(st.nextToken());
                second = Integer.parseInt(st.nextToken());
                graph.get(first).add(vertex[second]);
                graph.get(second).add(vertex[first]);
            }

        } catch (IOException ignore) {}

    }

    public static void main(String[] args) {
        readInput(args);
        doMagic();
    }
}