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
import java.util.*;

public class mis {

    public static List<SortedSet<Integer>> map = new ArrayList<SortedSet<Integer>>();

    public static Set<Integer> remove(int i, Set<Integer>s,int d) {
        Set<Integer> add = new HashSet<Integer>();
        for(Integer r:s) {
            map.get(r).remove(i);
            if(map.get(r).size()<d) {
                add.add(r);
            }
        }
        map.set(i,new TreeSet<Integer>());
        return add;
    }

    public static void main(String c[]) {
        int m,n,d,a,b;
        Scanner input = new Scanner(System.in);
        n=input.nextInt();
        map.add(0,new TreeSet<Integer>());
        for(int i=1;i<=n;i++) {
            map.add(i,new TreeSet<Integer>());
        }
        m=input.nextInt();
        d=input.nextInt();
        for(int i=1;i<=m;i++) {
            a=input.nextInt();
            b=input.nextInt();
            map.get(a).add(b);
            map.get(b).add(a);
        }

        //usuwanie < d
        boolean l=true;
        int i=0;
        while(l) {
            l=false;
            i=0;
            Set<Integer> add = new HashSet<Integer>();
            for (Iterator<SortedSet<Integer>> iterator = map.iterator(); iterator.hasNext();) {
                SortedSet<Integer> s = iterator.next();
                if(s.size()>0&&s.size()<d) {
                    add.addAll(remove(i, s, d));
                    l=true;
                }
                i++;
            }
            while(add.size()>0) {
                Set<Integer> add2 = new HashSet<Integer>();
                for (int t : add) {
                    add2.addAll(remove(t, map.get(t), d));
                }
                add = new HashSet<Integer>();
                add.addAll(add2);
            }
        }

        /*
        i=0;
        for(SortedSet<Integer> s:map) {
            if(s!=null) {
                System.out.print(i+". "+s.size()+" : ");
                for (Integer aa : s) System.out.print(aa + " ");
                System.out.println();
            } else
                System.out.println("0");
            i++;
        }
        */
        //System.exit(0);
        SortedSet<Integer> max = new TreeSet<Integer>();
        Set<Integer> acc;
        i=0;
        for (Iterator<SortedSet<Integer>> iterator = map.iterator(); iterator.hasNext();) {
            SortedSet<Integer> s = iterator.next();
            if(s!=null && s.size()>0 && !visited.containsKey(i)) {
                acc = new HashSet<Integer>();
                visit(i,s,acc);
                if(acc.size()>max.size()) {
                    max = new TreeSet<Integer>();
                    max.addAll(acc);
                }
            }
            i++;
        }

        if(max.size()>0) {
            System.out.println(max.size());
            for(int w:max) {
                System.out.print(w+" ");
            }
            System.out.println();
        } else {
            System.out.println("NIE");
        }
    }

    public static HashMap<Integer,Integer> visited = new HashMap<Integer,Integer>();

    public static void visit(int i, Set<Integer> v, Set<Integer> s) {
        visited.put(i,i);
        s.add(i);
        for(int a:v) {
            if(!visited.containsKey(a)) {
                visit(a,map.get(a),s);
            }
        }
    }

}