package cf;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Problem219D {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer = new PrintWriter(new OutputStreamWriter(System.out));

    int []readInts() throws IOException {
        String []s = reader.readLine().split(" ");
        int []ret = new int[s.length];
        for(int i = 0; i < s.length; i++) {
            ret[i] = Integer.parseInt(s[i]);
        }
        return ret;
    }

    class Node {
        List<Integer> in = new ArrayList<Integer>(), out = new ArrayList<Integer>();
        void addIn(Integer node) {
            in.add(node);
        }
        void addOut(Integer node) {
            out.add(node);
        }
    }

    Node[] nodes;
    void addEdge(int a, int b) {
        nodes[a].addOut(b);
        nodes[b].addIn(a);
    }

    int[] inCount, outCount, inCountR, outCountR;
    void dfs(int u, int parent) {
        for(int v: nodes[u].in) {
            if(v != parent) {
                dfs(v, u);
                inCount[u] += inCount[v] + 1;
                outCount[u] += outCount[v];
            }
            else {
                inCountR[u] = inCountR[v];
                outCountR[u] = outCountR[v] + 1;
            }
        }
        for(int v: nodes[u].out) {
            if(v != parent) {
                dfs(v, u);
                inCount[u] += inCount[v];
                outCount[u] += outCount[v] + 1;
            }
            else {
                inCountR[u] = inCountR[v] + 1;
                outCountR[u] = outCountR[v];
            }
        }
    }

    void solve() throws IOException {
        int n = readInts()[0];
        nodes = new Node[n + 1];
        for(int i = 1; i <= n; i++) {
            nodes[i] = new Node();
        }
        for(int i = 1; i < n; i++) {
            int[] edge = readInts();
            addEdge(edge[0], edge[1]);
        }
        inCount = new int[n + 1];
        outCount = new int[n + 1];
        inCountR = new int[n + 1];
        outCountR = new int[n + 1];
        dfs(1, 0);
        int[] changeCount = new int[n + 1];
        int opt = Integer.MAX_VALUE;
        for(int i = 1; i <= n; i++) {
            changeCount[i] = inCount[1] - inCountR[i] + outCountR[i];
            opt = Math.min(opt, changeCount[i]);
        }
        List<Integer> capitals = new ArrayList<Integer>();
        for(int i = 1; i <= n; i++) {
            if(opt == changeCount[i]) {
                capitals.add(i);
            }
        }
        writer.printf("%d\n", opt);
        for(Integer i: capitals) {
            writer.printf("%d ", i);
        }
        writer.flush();

    }

    public static void main(String[] args) throws IOException {
        new Problem219D().solve();
    }
}


//package cf;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Problem219D {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer = new PrintWriter(new OutputStreamWriter(System.out));

    int []readInts() throws IOException {
        String []s = reader.readLine().split(" ");
        int []ret = new int[s.length];
        for(int i = 0; i < s.length; i++) {
            ret[i] = Integer.parseInt(s[i]);
        }
        return ret;
    }

    class Node {
        List<Integer> in = new ArrayList<Integer>(), out = new ArrayList<Integer>();
        void addIn(Integer node) {
            in.add(node);
        }
        void addOut(Integer node) {
            out.add(node);
        }
    }

    Node[] nodes;
    void addEdge(int a, int b) {
        nodes[a].addOut(b);
        nodes[b].addIn(a);
    }

    int rootCount;
    int balance[];
    void dfs(int u, int parent, int b) {
        balance[u] = b;
        for(int v: nodes[u].in) {
            if(v != parent) {
                dfs(v, u, b - 1);
                rootCount++;
            }
        }
        for(int v: nodes[u].out) {
            if(v != parent) {
                dfs(v, u, b + 1);
            }
        }
    }

    void solve() throws IOException {
        int n = readInts()[0];
        nodes = new Node[n + 1];
        for(int i = 1; i <= n; i++) {
            nodes[i] = new Node();
        }
        for(int i = 1; i < n; i++) {
            int[] edge = readInts();
            addEdge(edge[0], edge[1]);
        }
        balance = new int[n + 1];
        dfs(1, 0, 0);
        int opt = Integer.MAX_VALUE;
        for(int i = 1; i <= n; i++) {
            opt = Math.min(opt, rootCount + balance[i]);
        }
        List<Integer> capitals = new ArrayList<Integer>();
        for(int i = 1; i <= n; i++) {
            if(opt == rootCount + balance[i]) {
                capitals.add(i);
            }
        }
        writer.printf("%d\n", opt);
        for(Integer i: capitals) {
            writer.printf("%d ", i);
        }
        writer.flush();

    }

    public static void main(String[] args) throws IOException {
        new Problem219D().solve();
    }
}


//package cf;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class Problem219D {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter writer = new PrintWriter(new OutputStreamWriter(System.out));

    int []readInts() throws IOException {
        String []s = reader.readLine().split(" ");
        int []ret = new int[s.length];
        for(int i = 0; i < s.length; i++) {
            ret[i] = Integer.parseInt(s[i]);
        }
        return ret;
    }

    class Node {
        List<Integer> in = new ArrayList<Integer>(), out = new ArrayList<Integer>();
        void addIn(Integer node) {
            in.add(node);
        }
        void addOut(Integer node) {
            out.add(node);
        }
    }

    Node[] nodes;
    void addEdge(int a, int b) {
        nodes[a].addOut(b);
        nodes[b].addIn(a);
    }

    int[] inCount, outCount, inCountR, outCountR;
    void dfs(int u, int parent) {
        for(int v: nodes[u].in) {
            if(v != parent) {
                dfs(v, u);
                inCount[u] += inCount[v] + 1;
                outCount[u] += outCount[v];
            }
            else {
                inCountR[u] = inCountR[v];
                outCountR[u] = outCountR[v] + 1;
            }
        }
        for(int v: nodes[u].out) {
            if(v != parent) {
                dfs(v, u);
                inCount[u] += inCount[v];
                outCount[u] += outCount[v] + 1;
            }
            else {
                inCountR[u] = inCountR[v] + 1;
                outCountR[u] = outCountR[v];
            }
        }
    }

    void solve() throws IOException {
        int n = readInts()[0];
        nodes = new Node[n + 1];
        for(int i = 1; i <= n; i++) {
            nodes[i] = new Node();
        }
        for(int i = 1; i < n; i++) {
            int[] edge = readInts();
            addEdge(edge[0], edge[1]);
        }
        inCount = new int[n + 1];
        outCount = new int[n + 1];
        inCountR = new int[n + 1];
        outCountR = new int[n + 1];
        dfs(1, 0);
        int[] changeCount = new int[n + 1];
        int opt = Integer.MAX_VALUE;
        for(int i = 1; i <= n; i++) {
            changeCount[i] = inCount[1] - inCountR[i] + outCountR[i];
            opt = Math.min(opt, changeCount[i]);
        }
        List<Integer> capitals = new ArrayList<Integer>();
        for(int i = 1; i <= n; i++) {
            if(opt == changeCount[i]) {
                capitals.add(i);
            }
        }
        writer.printf("%d\n", opt);
        for(Integer i: capitals) {
            writer.printf("%d ", i);
        }
        writer.flush();

    }

    public static void main(String[] args) throws IOException {
        new Problem219D().solve();
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Stack;

public class ProblemD {

    static boolean[] visited;
    static int[] count;
    static int[] total;
    static int[] parent;
    static int[] type;
    static List<Integer>[] road;
    static List<Integer>[] revroad;

    public static int dfs(int now) {
        if (visited[now]) {
            return 0;
        }
        visited[now] = true;
        int cnt = 0;
        for (int next : road[now]) {
            if (!visited[next]) {
                cnt += dfs(next);
                parent[next] = now;
                type[next] = -1;
            }
        }
        for (int next : revroad[now]) {
            if (!visited[next]) {
                cnt += dfs(next) + 1;
                parent[next] = now;
                type[next] = 1;
            }
        }
        count[now] = cnt;
        return cnt;
    }

    public static int dfs2(int now) {
        if (total[now] != -1) {
            return total[now];
        }

        int parent_total = dfs2(parent[now]);

        total[now] = parent_total - type[now];
        return total[now];
    }

    public static void main(String[] args) throws IOException {
        BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.valueOf(s.readLine());
        road = new List[N];
        revroad = new List[N];
        count = new int[N];
        total = new int[N];
        parent = new int[N];
        type = new int[N];
        Arrays.fill(total, -1);
        visited = new boolean[N];
        for (int i = 0 ; i < N ; i++) {
            road[i] = new ArrayList<Integer>();
            revroad[i] = new ArrayList<Integer>();
        }
        for (int i = 0 ; i < N-1 ; i++) {
            String[] data = s.readLine().split(" ");
            int from = Integer.valueOf(data[0])-1;
            int to = Integer.valueOf(data[1])-1;
            road[from].add(to);
            revroad[to].add(from);
        }

        dfs(0);
        total[0] = count[0];

        int min = Integer.MAX_VALUE;
        for (int i = 0 ; i < N ; i++) {
            dfs2(i);
            min = Math.min(min, total[i]);
        }

        System.out.println(min);
        StringBuffer b = new StringBuffer();
        for (int i = 0 ; i < N ; i++) {
            if (total[i] == min) {
                b.append(i+1).append(" ");
            }
        }
        System.out.println(b.substring(0, b.length()-1));
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Locale;
import java.util.StringTokenizer;

public class CFD {

    BufferedReader in;
    StringTokenizer st;
    PrintWriter out;

    public static void main(String[] args) {
        CFD t = new CFD();
        t.init();
    }

    int n;
    ArrayList<Integer>[] N;
    ArrayList<Integer>[] BN;
    int[] cost;
    int[] cost2;
    boolean[] visited;

    void run() throws Exception {
        n = Int();
        N = new ArrayList[n];
        BN = new ArrayList[n];
        visited = new boolean[n];
        cost = new int[n];
        cost2 = new int[n];

        for (int i = 0; i < n - 1; i++) {
            int a = Int() - 1;
            int b = Int() - 1;
            if (N[a] == null) {
                N[a] = new ArrayList<Integer>();
            }
            if (BN[b] == null) {
                BN[b] = new ArrayList<Integer>();
            }
            N[a].add(b);
            BN[b].add(a);
        }

        dfs1(0);

        Arrays.fill(visited, false);

        cost2[0] = cost[0];
        dfs2(-1, 0, 0);

        int min = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            min = Math.min(min, cost2[i]);
        }

        PrintLn(min);

        for (int i = 0; i < n; i++) {
            if (cost2[i] == min) {
                out.print((i + 1) + " ");
            }
        }
        out.println();
    }

    void dfs2(int a, int b, int c) {
        visited[b] = true;

        if (a != -1) {
            cost2[b] = cost2[a] + c;
        }

        if (N[b] != null) {
            for (Integer j : N[b]) {
                if (!visited[j] && j != a) {
                    dfs2(b, j, 1);
                }
            }
        }
        if (BN[b] != null) {
            for (Integer j : BN[b]) {
                if (!visited[j] && j != a) {
                    dfs2(b, j, -1);
                }
            }
        }
    }

    void dfs1(int a) {
        visited[a] = true;
        if (N[a] != null) {
            for (Integer j : N[a]) {
                if (!visited[j]) {
                    dfs1(j);
                    cost[a] += cost[j];
                }
            }
        }
        if (BN[a] != null) {
            for (Integer j : BN[a]) {
                if (!visited[j]) {
                    dfs1(j);
                    cost[a] += cost[j] + 1;
                }
            }
        }
    }

    void init() {
        try {
            Locale.setDefault(Locale.US);
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(new OutputStreamWriter(System.out));
            run();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    String next() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

    String String() throws Exception {
        return next();
    }

    int Int() throws Exception {
        return Integer.parseInt(next());
    }

    void PrintLn(Object line) {
        out.println(line);
    }

    void PrintArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            out.print(array[i] + " ");
        }
        out.println();
    }

}


//package round135;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;

public class D {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = ni();
		int[] from = new int[2*n-2];
		int[] to = new int[2*n-2];
		int[] w = new int[2*n-2];
		for(int i = 0;i < n-1;i++){
			int f = ni()-1;
			int t = ni()-1;
			from[2*i] = f;
			to[2*i] = t;
			w[2*i] = 1;
			from[2*i+1] = t;
			to[2*i+1] = f;
			w[2*i+1] = 0;
		}

		int[][][] g = packWD(n, from, to, w);
		int[][] pars = parents(g, 0);
		int[] par = pars[0], ord = pars[1];
		int[] dp = new int[n];
		for(int i = n-1;i >= 0;i--){
			for(int[] e : g[ord[i]]){
				if(par[ord[i]] != e[0]){
					dp[ord[i]] += (1-e[1]) + dp[e[0]];
				}
			}
		}

		int[] ep = new int[n];
		int[] lp = new int[n];
		for(int i = 0;i < n;i++){
			for(int[] e : g[ord[i]]){
				if(par[ord[i]] != e[0]){
					ep[e[0]] = ep[ord[i]] + e[1];
					lp[e[0]] = lp[ord[i]] + 1;
				}
			}
		}

		int min = 9999999;
		int[] can = new int[n];
		int p = 0;
		for(int i = 0;i < n;i++){
			int v = dp[0] + ep[i] - (lp[i] - ep[i]);
			if(v < min){
				min = v;
				p = 0;
				can[p++] = i;
			}else if(v == min){
				can[p++] = i;
			}
		}
		out.println(min);
		for(int i = 0;i < p;i++){
			if(i > 0)out.print(" ");
			out.print(can[i]+1);
		}
		out.println();
	}

	public static int[][] parents(int[][][] g, int root) {
		int n = g.length;
		int[] par = new int[n];
		Arrays.fill(par, -1);

		int[] q = new int[n];
		q[0] = root;
		for(int p = 0, r = 1;p < r;p++){
			int cur = q[p];
			for(int[] nex : g[cur]){
				if(par[cur] != nex[0]){
					q[r++] = nex[0];
					par[nex[0]] = cur;
				}
			}
		}
		return new int[][] { par, q };
	}

	public static int[][][] packWD(int n, int[] from, int[] to, int[] w) {
		int[][][] g = new int[n][][];
		int[] p = new int[n];
		for(int f : from)
			p[f]++;
		for(int i = 0;i < n;i++)
			g[i] = new int[p[i]][2];
		for(int i = 0;i < from.length;i++){
			--p[from[i]];
			g[from[i]][p[from[i]]][0] = to[i];
			g[from[i]][p[from[i]]][1] = w[i];
		}
		return g;
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception
	{
		new D().run();
	}

	public int ni()
	{
		try {
			int num = 0;
			boolean minus = false;
			while((num = is.read()) != -1 && !((num >= '0' && num <= '9') || num == '-'));
			if(num == '-'){
				num = 0;
				minus = true;
			}else{
				num -= '0';
			}

			while(true){
				int b = is.read();
				if(b >= '0' && b <= '9'){
					num = num * 10 + (b - '0');
				}else{
					return minus ? -num : num;
				}
			}
		} catch (IOException e) {
		}
		return -1;
	}

	public long nl()
	{
		try {
			long num = 0;
			boolean minus = false;
			while((num = is.read()) != -1 && !((num >= '0' && num <= '9') || num == '-'));
			if(num == '-'){
				num = 0;
				minus = true;
			}else{
				num -= '0';
			}

			while(true){
				int b = is.read();
				if(b >= '0' && b <= '9'){
					num = num * 10 + (b - '0');
				}else{
					return minus ? -num : num;
				}
			}
		} catch (IOException e) {
		}
		return -1;
	}

	public String ns()
	{
		try{
			int b = 0;
			StringBuilder sb = new StringBuilder();
			while((b = is.read()) != -1 && (b == '\r' || b == '\n' || b == ' '));
			if(b == -1)return "";
			sb.append((char)b);
			while(true){
				b = is.read();
				if(b == -1)return sb.toString();
				if(b == '\r' || b == '\n' || b == ' ')return sb.toString();
				sb.append((char)b);
			}
		} catch (IOException e) {
		}
		return "";
	}

	public char[] ns(int n)
	{
		char[] buf = new char[n];
		try{
			int b = 0, p = 0;
			while((b = is.read()) != -1 && (b == ' ' || b == '\r' || b == '\n'));
			if(b == -1)return null;
			buf[p++] = (char)b;
			while(p < n){
				b = is.read();
				if(b == -1 || b == ' ' || b == '\r' || b == '\n')break;
				buf[p++] = (char)b;
			}
			return Arrays.copyOf(buf, p);
		} catch (IOException e) {
		}
		return null;
	}

	double nd() { return Double.parseDouble(ns()); }
	boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


//package round135;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;

public class D2 {
	InputStream is;
	PrintWriter out;
	String INPUT = "";

	void solve()
	{
		int n = ni();
		int[] from = new int[2*n-2];
		int[] to = new int[2*n-2];
		int[] w = new int[2*n-2];
		for(int i = 0;i < n-1;i++){
			int f = ni()-1;
			int t = ni()-1;
			from[2*i] = f;
			to[2*i] = t;
			w[2*i] = 1;
			from[2*i+1] = t;
			to[2*i+1] = f;
			w[2*i+1] = 0;
		}

		int[][][] g = packWD(n, from, to, w);
		dp = 0;
		ep = new int[n];
		lp = new int[n];
		dfs(g, 0, -1);

		int min = 99999999;
		for(int i = 0;i < n;i++){
			min = Math.min(min, dp-(lp[i]-ep[i])+ep[i]);
		}
		out.println(min);
		boolean f = true;
		for(int i = 0;i < n;i++){
			if(min == dp-(lp[i]-ep[i])+ep[i]){
				if(!f)out.print(" ");
				f = false;
				out.print(i+1);
			}
		}
		out.println();
	}

	void dfs(int[][][] g, int cur, int prev)
	{
		for(int[] e : g[cur]){
			if(e[0] != prev){
				ep[e[0]] = ep[cur] + e[1];
				lp[e[0]] = lp[cur] + 1;
				dfs(g, e[0], cur);
				dp += 1-e[1];
			}
		}
	}

	int dp;

	int[] ep, lp;

	public static int[][][] packWD(int n, int[] from, int[] to, int[] w) {
		int[][][] g = new int[n][][];
		int[] p = new int[n];
		for(int f : from)
			p[f]++;
		for(int i = 0;i < n;i++)
			g[i] = new int[p[i]][2];
		for(int i = 0;i < from.length;i++){
			--p[from[i]];
			g[from[i]][p[from[i]]][0] = to[i];
			g[from[i]][p[from[i]]][1] = w[i];
		}
		return g;
	}

	void run() throws Exception
	{
		is = oj ? System.in : new ByteArrayInputStream(INPUT.getBytes());
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis()-s+"ms");
	}

	public static void main(String[] args) throws Exception
	{
		new D2().run();
	}

	public int ni()
	{
		try {
			int num = 0;
			boolean minus = false;
			while((num = is.read()) != -1 && !((num >= '0' && num <= '9') || num == '-'));
			if(num == '-'){
				num = 0;
				minus = true;
			}else{
				num -= '0';
			}

			while(true){
				int b = is.read();
				if(b >= '0' && b <= '9'){
					num = num * 10 + (b - '0');
				}else{
					return minus ? -num : num;
				}
			}
		} catch (IOException e) {
		}
		return -1;
	}

	public long nl()
	{
		try {
			long num = 0;
			boolean minus = false;
			while((num = is.read()) != -1 && !((num >= '0' && num <= '9') || num == '-'));
			if(num == '-'){
				num = 0;
				minus = true;
			}else{
				num -= '0';
			}

			while(true){
				int b = is.read();
				if(b >= '0' && b <= '9'){
					num = num * 10 + (b - '0');
				}else{
					return minus ? -num : num;
				}
			}
		} catch (IOException e) {
		}
		return -1;
	}

	public String ns()
	{
		try{
			int b = 0;
			StringBuilder sb = new StringBuilder();
			while((b = is.read()) != -1 && (b == '\r' || b == '\n' || b == ' '));
			if(b == -1)return "";
			sb.append((char)b);
			while(true){
				b = is.read();
				if(b == -1)return sb.toString();
				if(b == '\r' || b == '\n' || b == ' ')return sb.toString();
				sb.append((char)b);
			}
		} catch (IOException e) {
		}
		return "";
	}

	public char[] ns(int n)
	{
		char[] buf = new char[n];
		try{
			int b = 0, p = 0;
			while((b = is.read()) != -1 && (b == ' ' || b == '\r' || b == '\n'));
			if(b == -1)return null;
			buf[p++] = (char)b;
			while(p < n){
				b = is.read();
				if(b == -1 || b == ' ' || b == '\r' || b == '\n')break;
				buf[p++] = (char)b;
			}
			return Arrays.copyOf(buf, p);
		} catch (IOException e) {
		}
		return null;
	}

	double nd() { return Double.parseDouble(ns()); }
	boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	void tr(Object... o) { if(!oj)System.out.println(Arrays.deepToString(o)); }
}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        /*for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            //status1[i]=-1;//Unexplored;
        }
        */
        Flip =new int[N+1];
        int[] allcount=new int[1];
       // countdfs(1,nodes,1,status1,allcount);

        //Redentiretree=N-1-allcount[0];

        int[] count=new int[3];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            Flip[i]+=count[2];
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==2) return;
        if(status[index]==0){
            Flip[index]= - 2*count[1]+count[0];
            status[index]=1;
            int outcount=nodes[index].OutList.size();

            for(int j:nodes[index].InList){
                nodes[index].OutList.add(j);
            }

            for(int i:nodes[index].OutList){
                if(status[i]==1) continue;
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;
                    if(status[i]!=1){
                        count[2]++;
                    }

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=2;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            status1[i]=-1;//Unexplored;
        }
        Flip =new int[N+1];
        int[] allcount=new int[1];
        countdfs(1,nodes,1,status1,allcount);

        Redentiretree=N-1-allcount[0];
        //System.out.println("Redentiretree:"+Redentiretree);

        //for(int vert=1;vert<=N;vert++){
        int[] count=new int[2];//Count[0] -> rootdistance Count[1] -> number of red

        dfs(1,nodes,1,status,count);
        //Flip[vert]=Redentiretree - 2*Redonpath + Distancetoroot;
        //System.out.println("Flip"+vert+":"+Flip[vert]);
        //for(int i=1;i<=N;i++){
          //  status[i]=-1;//Unexplored;
        //}

        //}
        int min=1000000000;
        for(int i=1;i<=N;i++){
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==1) return;
        if(status[index]==-1){
            Flip[index]=Redentiretree - 2*count[1]+count[0];
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=1;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       Nodes[N]=new Node();
       for(int i=1;i<=N-1;i++){
           Nodes[i]=new Node();
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            status1[i]=-1;//Unexplored;
        }
        Flip =new int[N+1];
        int[] allcount=new int[1];
        countdfs(1,nodes,1,status1,allcount);
        Redentiretree=N-1-allcount[0];
        int[] count=new int[2];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==1) return;
        if(status[index]==-1){
            Flip[index]=Redentiretree - 2*count[1]+count[0];
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=1;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       int[][] nodearray=new int[N+1][N+1];
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            status1[i]=-1;//Unexplored;
        }
        int[] Flip =new int[N+1];
        int[] allcount=new int[1];
        countdfs(1,nodes,1,status1,allcount);

        Redentiretree=N-1-allcount[0];
        //System.out.println("Redentiretree:"+Redentiretree);

        for(int vert=1;vert<=N;vert++){
        int[] count=new int[2];//Count[0] -> rootdistance Count[1] -> number of red

        dfs(vert,nodes,vert,1,status,count);
        Flip[vert]=Redentiretree - 2*Redonpath + Distancetoroot;
        //System.out.println("Flip"+vert+":"+Flip[vert]);
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
        }

        }
        int min=1000000000;
        for(int i=1;i<=N;i++){
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int vert, Node[] nodes, int index,int root,int[] status, int[] count) {
        if(index==root) {
            Distancetoroot = count[0];
            Redonpath=count[1];
            //System.out.println("distance:"+Distancetoroot);
            //System.out.println("redonpath:"+Redonpath);
            return;
        }
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {

                    count[1]++;

                    }
                else{

                    forward=false;
                }

                //System.out.println(i);
                dfs(vert,nodes,i,root,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=1;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        /*for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            //status1[i]=-1;//Unexplored;
        }
        */
        Flip =new int[N+1];
        int[] allcount=new int[1];
       // countdfs(1,nodes,1,status1,allcount);

        //Redentiretree=N-1-allcount[0];

        int[] count=new int[3];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            Flip[i]+=count[2];
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==2) return;
        if(status[index]==0){
            Flip[index]= - 2*count[1]+count[0];
            status[index]=1;
            int outcount=nodes[index].OutList.size();
            int incount=nodes[index].InList.size();
            /*
            for(int j:nodes[index].InList){
                nodes[index].OutList.add(j);
            }
            */
            for(int t=1;t<=outcount+incount;t++){
                int i=0;
                if(t<=outcount) {i=nodes[index].OutList.get(t-1);}
                else{i=nodes[index].InList.get(t-1-outcount);}
                if(status[i]==1) continue;
                count[0]++;
                boolean forward=true;
                if(t>outcount)
                {

                    count[1]++;
                    if(status[i]!=1){
                        count[2]++;
                    }

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=2;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            status1[i]=-1;//Unexplored;
        }
        int[] Flip =new int[N+1];
        int[] allcount=new int[1];
        countdfs(1,nodes,1,status1,allcount);

        Redentiretree=N-1-allcount[0];
        //System.out.println("Redentiretree:"+Redentiretree);

        for(int vert=1;vert<=N;vert++){
        int[] count=new int[2];//Count[0] -> rootdistance Count[1] -> number of red

        dfs(vert,nodes,vert,1,status,count);
        Flip[vert]=Redentiretree - 2*Redonpath + Distancetoroot;
        //System.out.println("Flip"+vert+":"+Flip[vert]);
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
        }

        }
        int min=1000000000;
        for(int i=1;i<=N;i++){
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int vert, Node[] nodes, int index,int root,int[] status, int[] count) {
        if(index==root) {
            Distancetoroot = count[0];
            Redonpath=count[1];
            //System.out.println("distance:"+Distancetoroot);
            //System.out.println("redonpath:"+Redonpath);
            return;
        }
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {

                    count[1]++;

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(vert,nodes,i,root,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=1;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        /*for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            //status1[i]=-1;//Unexplored;
        }
        */
        Flip =new int[N+1];
        int[] allcount=new int[1];
       // countdfs(1,nodes,1,status1,allcount);

        //Redentiretree=N-1-allcount[0];

        int[] count=new int[3];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            Flip[i]+=count[2];
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==2) return;
        if(status[index]==0){
            Flip[index]= - 2*count[1]+count[0];
            status[index]=1;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;
                    if(status[i]!=1){
                        count[2]++;
                    }

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=2;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            //status1[i]=-1;//Unexplored;
        }
        Flip =new int[N+1];
        int[] allcount=new int[1];
       // countdfs(1,nodes,1,status1,allcount);

        //Redentiretree=N-1-allcount[0];

        int[] count=new int[3];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            Flip[i]+=count[2];
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==1) return;
        if(status[index]==-1){
            Flip[index]= - 2*count[1]+count[0];
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;
                    if(status[i]!=0){
                        count[2]++;
                    }

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=1;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        /*for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            //status1[i]=-1;//Unexplored;
        }
        */
        Flip =new int[N+1];
        int[] allcount=new int[1];
       // countdfs(1,nodes,1,status1,allcount);

        //Redentiretree=N-1-allcount[0];

        int[] count=new int[3];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            Flip[i]+=count[2];
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==2) return;
        if(status[index]==0){
            Flip[index]= - 2*count[1]+count[0];
            status[index]=1;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                if(status[i]==1) continue;
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;
                    if(status[i]!=1){
                        count[2]++;
                    }

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=2;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       int[][] nodearray=new int[N+1][N+1];
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }
       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);

       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];
        for(int i=1;i<=N;i++){
            status[i]=-1;//Unexplored;
            status1[i]=-1;//Unexplored;
        }
        Flip =new int[N+1];
        int[] allcount=new int[1];
        countdfs(1,nodes,1,status1,allcount);

        Redentiretree=N-1-allcount[0];
        //System.out.println("Redentiretree:"+Redentiretree);

        //for(int vert=1;vert<=N;vert++){
        int[] count=new int[2];//Count[0] -> rootdistance Count[1] -> number of red

        dfs(1,nodes,1,status,count);
        //Flip[vert]=Redentiretree - 2*Redonpath + Distancetoroot;
        //System.out.println("Flip"+vert+":"+Flip[vert]);
        //for(int i=1;i<=N;i++){
          //  status[i]=-1;//Unexplored;
        //}

        //}
        int min=1000000000;
        for(int i=1;i<=N;i++){
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==1) return;
        if(status[index]==-1){
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=0){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=1;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==1) return;
        if(status[index]==-1){
            Flip[index]=Redentiretree - 2*count[1]+count[0];
            status[index]=0;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=1;

        }

    }

}


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Scanner;

/*************************************************************************
 *  Compilation:  javac TestAlgs4.java
 *  Execution:    java TestAlgs4
 *  Dependencies: StdDraw.java
 *                http://introcs.cs.princeton.edu/mac/cover.jpg
 *
 *  Draws a blue bullseye and textbook graphic.
 *
 *************************************************************************/
public class Sourcecode {
    public static int Redentiretree;
    public static int Distancetoroot;
    public static int Redonpath;
    public static int[] Flip;
    public static class Node{
        public ArrayList<Integer> InList;
        public ArrayList<Integer> OutList;
        Node(){
            InList=new ArrayList<Integer>();
            OutList=new ArrayList<Integer>();
        }
    }
    public static void main (String[] args) {

       Scanner scan=new Scanner(System.in);
       int N = scan.nextInt();
       Node[] Nodes=new Node[N+1];
       for(int i=1;i<=N;i++){
           Nodes[i]=new Node();
       }

       for(int i=1;i<=N-1;i++){
           int from=scan.nextInt();
           int to=scan.nextInt();
           Nodes[from].OutList.add(to);
           Nodes[to].InList.add(from);
       }

       dodfs(Nodes,N);
    }
    private static void dodfs(Node[] nodes,int N) {
        int[] status=new int[N+1];
        int[] status1=new int[N+1];

        Flip =new int[N+1];
        int[] allcount=new int[1];
        countdfs(1,nodes,1,status1,allcount);
        Redentiretree=N-1-allcount[0];
        int[] count=new int[2];

        dfs(1,nodes,1,status,count);

        int min=1000000000;
        for(int i=1;i<=N;i++){
            if(Flip[i]<min) min=Flip[i];
        }

        System.out.println(min);
        for(int i=1;i<=N;i++){
            if(Flip[i]==min) System.out.print(i+" ");
        }

    }
    private static void countdfs(int root,Node[] nodes, int index,int[] status,int[] count){
        if(status[index]==2) return;
        if(status[index]==0){
            status[index]=1;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                boolean forward=true;
                if(nodes[index].OutList.contains(i))
                {
                    if(status[i]!=1){
                    count[0]++;
                    }

                    }
                else{
                    forward=false;
                }

                //System.out.println(i);
                countdfs(root,nodes,i,status,count);
            }
            status[index]=2;

        }
    }

    private static void dfs(int root, Node[] nodes, int index,int[] status, int[] count) {

        if(status[index]==2) return;
        if(status[index]==0){
            Flip[index]=Redentiretree - 2*count[1]+count[0];
            status[index]=1;
            ArrayList<Integer> Allneighbor=new ArrayList<Integer>();
            for(int i:nodes[index].OutList){
                Allneighbor.add(i);
            }
            for(int j:nodes[index].InList){
                Allneighbor.add(j);
            }

            for(int i:Allneighbor){
                count[0]++;
                boolean forward=true;
                if(nodes[index].InList.contains(i))
                {

                    count[1]++;

                    }
                else{
                    //System.out.println("Nide");
                    forward=false;
                }

                //System.out.println(i);
                dfs(root,nodes,i,status,count);
                count[0]--;
                if(forward) count[1]--;
            }
            status[index]=2;

        }

    }

}


import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;

public class Main {
	public static void main(String[] args) {
		Class<?> here = new Object(){}.getClass().getEnclosingClass();
		try {
			String packageName = here.getPackage().getName();
			System.setIn(new FileInputStream("src/" + packageName + "/input.txt"));
//			System.setOut(new PrintStream(new FileOutputStream("src/" + packageName + "/result.txt")));
		} catch (FileNotFoundException e) {
		} catch (NullPointerException e) {
		}

		try {
			String className = here.getName();
			Object object = Class.forName(className).newInstance();
			object.getClass().getMethod("run").invoke(object);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	void tr(Object... os) {
		System.err.println(deepToString(os));
	}

	Scanner sc = new Scanner(System.in);
	public void run() {
		int n = sc.nextInt();
		V[] vs = new V[n];
		for (int i = 0; i < n; i++)
			vs[i] = new V();

		for (int i = 0; i < n - 1; ++i) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			a--;
			b--;
			vs[a].add(vs[b]);
		}

		// まず、どこか点からdfs
		vs[0].ans = dfs(vs[0], null, 0);

		for (int i = 1; i < vs.length; ++i) {
			vs[i].ans = vs[0].ans - vs[i].cost;
		}

		int ans = 1001001001;
		for (int i = 0; i < n; i++) {
			ans = min(ans, vs[i].ans);
		}
		System.out.println(ans);
		int count = 0;
		for (int i = 0; i < n; i++) {
			if (ans == vs[i].ans) {
				if (count > 0) {
					System.out.print(" ");
				}
				System.out.print(i + 1);
				count++;
			}
		}
	}

	int dfs(V v, V prev, int cost) {
		v.cost = cost;
		int f = 0;
		for (E e : v.es) {
			if (e.to != prev) {
				f += (e.cost == 1 ? 1 : 0);
				f += dfs(e.to, v, cost + (e.cost == 0 ? -1 : 1));
			}
		}
		return f;
	}

	class V {
		List<E> es = new ArrayList<E>();
		int ans = 0;
		int cost = 0;
		public void add(V to) {
			es.add(new E(to, 0));
			to.es.add(new E(this, 1));
		}
	}

	class E {
		V to;
		int cost;
		public E(V to, int cost) {
			this.to = to;
			this.cost = cost;
		}

	}

}


import java.util.*;
import java.io.*;
public class D {
	Map<Integer, List<Integer>> map_out;
	Map<Integer, List<Integer>> map_in;
	public int count(int x, int n){
		boolean[] used = new boolean[n+1];
		int key = 0;
		int ret = 0;
		Set<Integer> set = new HashSet<Integer>();
		set.add(x);
		used[x] = true;
		while( key < n-1 ){
			Set<Integer> next = new HashSet<Integer>();
			for(Integer a : set){
				List<Integer> list1 = map_in.get(a);
				List<Integer> list2 = map_out.get(a);
				int add1 = (list1 == null) ? 0 : list1.size();
				int add2 = (list2 == null) ? 0 : list2.size();
				if( list1 != null ){
	//				writer.println(list1);
					for(Integer b : list1){
						if( used[b] ){
							continue;
						}
						next.add(b);
						used[b] = true;
						ret++;
						key++;
					}
				}
				if( list2 != null ){
	//				writer.println(list2);
					for(Integer b : list2){
						if( used[b] ){
							continue;
						}
						next.add(b);
						used[b] = true;
						key++;
					}
				}
			}
			set = next;
		}
		return ret;
	}
	public void solve() throws IOException {
		int n = nextInt();
		map_out = new HashMap<Integer, List<Integer>>();
		map_in = new HashMap<Integer, List<Integer>>();
		for(int i = 0; i < n-1; i++){
			int x = nextInt();
			int y = nextInt();
			List<Integer> list1 = (map_out.get(x) == null) ? new ArrayList<Integer>() : map_out.get(x);
			list1.add(y);
			map_out.put(x, list1);
			List<Integer> list2 = (map_in.get(y) == null) ? new ArrayList<Integer>() : map_in.get(y);
			list2.add(x);
			map_in.put(y, list2);
		}
		Set<Integer> set = new HashSet<Integer>();
		int min = n;
		for(int i = 1; i <= n; i++){
			int key = count(i, n);
	//		writer.println("i = " + i + ", key = " + key);
			if( key < min ){
				set = new HashSet<Integer>();
				set.add(i);
				min = key;
			} else if( key == min ){
				set.add(i);
			}
		}
		List<Integer> ans = new ArrayList<Integer>(set);
		Collections.sort(ans);
		writer.println(min);
		for(Integer x : ans){
			writer.print(x + " ");
		}
		writer.println();
	}

	public static void main(String[] args) throws IOException {
		new D().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() throws IOException {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			tokenizer = null;
			writer = new PrintWriter(System.out);
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

}


import java.util.*;
import java.io.*;
public class D {
	Map<Integer, List<Integer>> map_out;
	Map<Integer, List<Integer>> map_in;
	int[] inverse;
	int[] dist;
	public int count(int n){
		int[] used = new int[n+1];
		int key = 0;
		int ret = 0;
		int c = 0;
		Set<Integer> set = new HashSet<Integer>();
		set.add(1);
		used[1] = -1;
		while( key < n-1 ){
			c++;
			Set<Integer> next = new HashSet<Integer>();
			for(Integer a : set){
				List<Integer> list1 = map_in.get(a);
				List<Integer> list2 = map_out.get(a);
				if( list1 != null ){
					for(Integer b : list1){
						if( used[b] < 0 ){
							continue;
						}
						dist[b] = c;
						next.add(b);
						inverse[b] = inverse[a]+1;
						used[b] = -1;
						ret++;
						key++;
					}
				}
				if( list2 != null ){
					for(Integer b : list2){
						if( used[b] < 0 ){
							continue;
						}
						dist[b] = c;
						next.add(b);
						used[b] = -1;
						inverse[b] = inverse[a];
						key++;
					}
				}
			}
			set = next;
		}
		return ret;
	}
	public void solve() throws IOException {
		int n = nextInt();
		map_out = new HashMap<Integer, List<Integer>>();
		map_in = new HashMap<Integer, List<Integer>>();
		inverse = new int[n+1];
		dist = new int[n+1];
		for(int i = 0; i < n-1; i++){
			int x = nextInt();
			int y = nextInt();
			List<Integer> list1 = (map_out.get(x) == null) ? new ArrayList<Integer>() : map_out.get(x);
			list1.add(y);
			map_out.put(x, list1);
			List<Integer> list2 = (map_in.get(y) == null) ? new ArrayList<Integer>() : map_in.get(y);
			list2.add(x);
			map_in.put(y, list2);
		}
		Set<Integer> set = new HashSet<Integer>();
		int key = count(n);
		int min = key;
		set.add(1);
		for(int i = 2; i <= n; i++){
			if( map_in.get(i) != null && map_in.get(i).size() > min ){
				continue;
			}
			int temp = key+dist[i]-2*inverse[i];
	//		writer.println("i = " + i + ", temp = " + temp);
			if( temp < min ){
				set = new HashSet<Integer>();
				set.add(i);
				min = temp;
			} else if( temp == min ){
				set.add(i);
			}
		}
		List<Integer> ans = new ArrayList<Integer>(set);
		Collections.sort(ans);
		writer.println(min);
		for(Integer x : ans){
			writer.print(x + " ");
		}
		writer.println();
	}

	public static void main(String[] args) throws IOException {
		new D().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() throws IOException {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			tokenizer = null;
			writer = new PrintWriter(System.out);
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

}


import java.util.*;
import java.io.*;
public class D {
	public int count(Map<Integer, List<Integer>> map, int x){
		if( map.get(x) == null ){
			return 0;
		}
		int sum = map.get(x).size();
		for(Integer a : map.get(x)){
			sum += count(map, a);
		}
		return sum;
	}
	public void solve() throws IOException {
		int n = nextInt();
		Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();
		for(int i = 0; i < n-1; i++){
			int x = nextInt();
			int y = nextInt();
			List<Integer> list = (map.get(x) == null) ? new ArrayList<Integer>() : map.get(x);
			list.add(y);
			map.put(x, list);
		}
		Set<Integer> set = new HashSet<Integer>();
		int max = 0;
		for(Integer x : map.keySet()){
			int key = count(map, x);
			if( key > max ){
				set = new HashSet<Integer>();
				set.add(x);
				max = key;
			} else if( key == max ){
				set.add(x);
			}
		}
		List<Integer> ans = new ArrayList<Integer>(set);
		Collections.sort(ans);
		writer.println(n-1-max);
		for(Integer x : ans){
			writer.print(x + " ");
		}
		writer.println();
	}

	public static void main(String[] args) throws IOException {
		new D().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() throws IOException {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			tokenizer = null;
			writer = new PrintWriter(System.out);
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

}


import java.util.*;
import java.io.*;
public class D {
	public int count(Map<Integer, List<Integer>> map, int x){
		if( map.get(x) == null ){
			return 0;
		}
		int sum = map.get(x).size();
		for(Integer a : map.get(x)){
			sum += count(map, a);
		}
		return sum;
	}
	public void solve() throws IOException {
		int n = nextInt();
		Map<Integer, List<Integer>> map = new HashMap<Integer, List<Integer>>();
		for(int i = 0; i < n-1; i++){
			int x = nextInt();
			int y = nextInt();
			List<Integer> list = (map.get(x) == null) ? new ArrayList<Integer>() : map.get(x);
			list.add(y);
			map.put(x, list);
		}
		Set<Integer> set = new HashSet<Integer>();
		int max = 0;
		for(Integer x : map.keySet()){
			int key = count(map, x);
			if( key > max ){
				set = new HashSet<Integer>();
				set.add(x);
				max = key;
			} else if( key == max ){
				set.add(x);
			}
		}
		writer.println(n-1-max);
		for(Integer x : set){
			writer.print(x + " ");
		}
		writer.println();
	}

	public static void main(String[] args) throws IOException {
		new D().run();
	}

	BufferedReader reader;
	StringTokenizer tokenizer;
	PrintWriter writer;

	public void run() throws IOException {
		try {
			reader = new BufferedReader(new InputStreamReader(System.in));
			tokenizer = null;
			writer = new PrintWriter(System.out);
			solve();
			reader.close();
			writer.close();
		} catch (Exception e) {
			e.printStackTrace();
			System.exit(1);
		}
	}

	public int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	public double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	public String nextToken() throws IOException {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			tokenizer = new StringTokenizer(reader.readLine());
		}
		return tokenizer.nextToken();
	}

}


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class D implements Runnable{

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws FileNotFoundException{
		if (ONLINE_JUDGE){
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		}else{
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
	}

	String readString() throws IOException{
		while(!tok.hasMoreTokens()){
			try{
				tok = new StringTokenizer(in.readLine());
			}catch (Exception e){
				return null;
			}
		}
		return tok.nextToken();
	}

	int readInt() throws IOException{
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException{
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException{
		return Double.parseDouble(readString());
	}

	public static void main(String[] args){
		new Thread(null, new D(), "", 50 * (1L << 20)).start();
	}

	long timeBegin, timeEnd;

	void time(){
		timeEnd = System.currentTimeMillis();
		System.err.println("Time = " + (timeEnd - timeBegin));
	}

	long memoryTotal, memoryFree;

	void memory(){
		memoryFree = Runtime.getRuntime().freeMemory();
		System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10) + " KB");
	}

	void debug(Object... objects){
		if (DEBUG){
			for (Object o: objects){
				System.err.println(o.toString());
			}
		}
	}

	public void run(){
		try{
			timeBegin = System.currentTimeMillis();
			memoryTotal = Runtime.getRuntime().freeMemory();
			init();
			solve();
			out.close();
			time();
			memory();
		}catch (Exception e){
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	boolean DEBUG = false;

	int n;
	List<Integer>[] graph;

	int[] dp;

	boolean[] used;
	int[] p;

	int root;

	void solve() throws IOException{
		n = readInt();

		graph = new List[n];
		for (int i = 0; i < n; ++i){
			graph[i] = new ArrayList<Integer>();
		}

		for (int i = n - 1; i > 0; --i){
			int from = readInt() - 1;
			int to = readInt() - 1;

			graph[from].add(to);
			graph[to].add(-from - 1);
		}

		root = 0; //new Random().nextInt(n);

		used = new boolean[n];
		p = new int[n];

		dp = new int[n];
		dfs(root);
		Arrays.fill(used, false);
		dfs2(root);

		int min_v = 0;
		for (int v = 1; v < n; ++v){
			if (dp[min_v]> dp[v]){
				min_v = v;
			}
		}

		out.println(dp[min_v]);
		List<Integer> ans = new ArrayList<Integer>();
		for (int v = 0; v < n; ++v){
			if (dp[v] == dp[min_v]){
				ans.add(v + 1);
			}
		}

		for (int v: ans){
			out.print(v + " ");
		}
	}

	void dfs(int from){
		used[from] = true;

		for (int v: graph[from]){
			int to = (v < 0? (-v - 1): v);
			if (used[to]) continue;

			p[to] = (v < 0? from: (-from - 1));
			dfs(to);

			dp[from] += dp[to] + (v < 0? 1: 0);
		}
	}

	void dfs2(int from){
		used[from] = true;

		if (from != root){
			int P = (p[from] < 0? -p[from] - 1: p[from]);
			dp[from] = (p[from] < 0? dp[P] + 1: dp[P] - 1);
		}

		for (int v: graph[from]){
			int to = (v < 0? (-v - 1): v);
			if (used[to]) continue;

			dfs2(to);
		}
	}
}


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class D implements Runnable{

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws FileNotFoundException{
		if (ONLINE_JUDGE){
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		}else{
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
	}

	String readString() throws IOException{
		while(!tok.hasMoreTokens()){
			try{
				tok = new StringTokenizer(in.readLine());
			}catch (Exception e){
				return null;
			}
		}
		return tok.nextToken();
	}

	int readInt() throws IOException{
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException{
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException{
		return Double.parseDouble(readString());
	}

	public static void main(String[] args){
		new Thread(null, new D(), "", 200 * (1L << 20)).start();
	}

	long timeBegin, timeEnd;

	void time(){
		timeEnd = System.currentTimeMillis();
		System.err.println("Time = " + (timeEnd - timeBegin));
	}

	long memoryTotal, memoryFree;

	void memory(){
		memoryFree = Runtime.getRuntime().freeMemory();
		System.err.println("Memory = " + ((memoryTotal - memoryFree) >> 10) + " KB");
	}

	void debug(Object... objects){
		if (DEBUG){
			for (Object o: objects){
				System.err.println(o.toString());
			}
		}
	}

	public void run(){
		try{
			timeBegin = System.currentTimeMillis();
			memoryTotal = Runtime.getRuntime().freeMemory();
			init();
			solve();
			out.close();
			time();
			memory();
		}catch (Exception e){
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	boolean DEBUG = false;

	int n;
	List<Integer>[] graph;

	int[] dp;

	boolean[] used;
	int[] p;

	int root;

	void solve() throws IOException{
		n = readInt();

		graph = new List[n];
		for (int i = 0; i < n; ++i){
			graph[i] = new ArrayList<Integer>();
		}

		for (int i = n - 1; i > 0; --i){
			int from = readInt() - 1;
			int to = readInt() - 1;

			graph[from].add(to);
			graph[to].add(-from - 1);
		}

		root = 0; //new Random().nextInt(n);

		used = new boolean[n];
		p = new int[n];

		dp = new int[n];
		dfs(root);
		Arrays.fill(used, false);
		dfs2(root);

		int min_v = 0;
		for (int v = 1; v < n; ++v){
			if (dp[min_v]> dp[v]){
				min_v = v;
			}
		}

		out.println(dp[min_v]);
		List<Integer> ans = new ArrayList<Integer>();
		for (int v = 0; v < n; ++v){
			if (dp[v] == dp[min_v]){
				ans.add(v + 1);
			}
		}

		for (int v: ans){
			out.print(v + " ");
		}
	}

	void dfs(int from){
		used[from] = true;

		for (int v: graph[from]){
			int to = (v < 0? (-v - 1): v);
			if (used[to]) continue;

			p[to] = (v < 0? from: (-from - 1));
			dfs(to);

			dp[from] += dp[to] + (v < 0? 1: 0);
		}
	}

	void dfs2(int from){
		used[from] = true;

		if (from != root){
			int P = (p[from] < 0? -p[from] - 1: p[from]);
			dp[from] = (p[from] < 0? dp[P] + 1: dp[P] - 1);
		}

		for (int v: graph[from]){
			int to = (v < 0? (-v - 1): v);
			if (used[to]) continue;

			dfs2(to);
		}
	}
}


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;

import static java.lang.Math.*;

public class D {

    final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
    BufferedReader in;
    PrintWriter out;
    StringTokenizer tok = new StringTokenizer("");

    ArrayList<Edge>[] g;
    int r;
    boolean[] used;
    int[] d;

    class Edge{
        int to;
        boolean rev;
        public Edge(int to, boolean rev) {
            this.to = to;
            this.rev = rev;
        }
    }

    void solve() throws IOException {
        int n = readInt();
        g= new ArrayList[n];
        for(int i = 0; i < n; i++){
            g[i] = new ArrayList<Edge>();
        }
        for(int i = 0; i < n-1; i++){
            int from = readInt()-1;
            int to = readInt()-1;
            g[from].add(new Edge(to, true));
            g[to].add(new Edge(from, false));
        }
        r = 0;
        used = new boolean[n];
        dfs(0);
        d = new int[n];
        d[0] = r;
        used = new boolean[n];
        dfs2(0);
        int min = n + 1;
        for(int i = 0; i < n; i++){
            min = min(min, d[i]);
        }
        out.println(min);
        for(int i = 0; i < n; i++){
            if(d[i] == min){
                out.print((i+1) + " ");
            }
        }
    }

    void dfs2(int from){
        used[from] = true;
        for(Edge e: g[from]){
            if(!used[e.to]){
                if(!e.rev){
                    d[e.to] = d[from]-1;
                }
                else{
                    d[e.to] = d[from]+1;
                }

                dfs2(e.to);
            }
        }
    }

    void dfs(int from){
        used[from] = true;
        for(Edge e: g[from]){
            if(!used[e.to]){
                if(!e.rev) r++;
                dfs(e.to);
            }
        }
    }

    void init() throws FileNotFoundException {
        if (ONLINE_JUDGE) {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
        } else {
            in = new BufferedReader(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");
        }
    }

    String readString() throws IOException {
        while (!tok.hasMoreTokens()) {
            tok = new StringTokenizer(in.readLine());
        }
        return tok.nextToken();
    }

    int readInt() throws IOException {
        return Integer.parseInt(readString());
    }

    long readLong() throws IOException {
        return Long.parseLong(readString());
    }

    double readDouble() throws IOException {
        return Double.parseDouble(readString());
    }

    int[] readArr(int n) throws IOException {
        int[] res = new int[n];
        for (int i = 0; i < n; i++) {
            res[i] = readInt();
        }
        return res;
    }

    long[] readArrL(int n) throws IOException {
        long[] res = new long[n];
        for (int i = 0; i < n; i++) {
            res[i] = readLong();
        }
        return res;
    }

    public static void main(String[] args) {
        new D().run();
    }

    public void run() {
        try {
            long t1 = System.currentTimeMillis();
            init();
            solve();
            out.close();
            long t2 = System.currentTimeMillis();
            System.err.println("Time = " + (t2 - t1));
        } catch (Exception e) {
            e.printStackTrace(System.err);
            System.exit(-1);
        }
    }
}


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

public class C135D
{
    static int[] s, t;
    static ArrayList<Integer>[] list, rlist;
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        s = new int[n-1];
        t = new int[n-1];
        list = new ArrayList[n];
        rlist = new ArrayList[n];
        for (int i = 0; i < n; i++)
        {
            list[i] = new ArrayList<Integer>(1);
            rlist[i] = new ArrayList<Integer>(1);
        }
        for (int i = 0; i < n - 1; i++)
        {
            s[i] = sc.nextInt() - 1;
            t[i] = sc.nextInt() - 1;
            list[s[i]].add(i);
            rlist[t[i]].add(i);
        }
        int[] d = new int[n-1];
        int[] d2 = new int[n-1];
        Arrays.fill(d, -1);
        Arrays.fill(d2, -1);

        for (int i = 0; i < n-1; i++)
        {
            d[i] = markfwd(d, d2, i);
            d2[i] = markback(d, d2, i);
        }
        int[] sum = new int[n];
        int best = n + 1;
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < list[i].size(); j++)
            {
                int x = list[i].get(j);
                sum[i] += d[x];
            }
            for (int j = 0; j < rlist[i].size(); j++)
            {
                int x = rlist[i].get(j);
                sum[i] += d2[x] + 1;
            }
            if (sum[i] < best)
            {
                best = sum[i];
            }
        }
        System.out.println(best);
        boolean first = true;
        for (int i = 0; i < n; i++)
        {
            if (sum[i] == best)
            {
                if (!first) System.out.print(" ");
                first = false;
                System.out.print(i+1);
            }
        }
        System.out.println();

    }

    private static int markfwd(int[] d, int[] d2, int edge)
    {
        //System.out.println("Marking forward " + edge);
        if (d[edge] != -1)
        {
            return d[edge];
        }
        int ep = t[edge];
        int sum = 0;
        for (int i = 0; i < list[ep].size(); i++)
        {
            int x = list[ep].get(i);
            d[x] = markfwd(d, d2, x);
            sum += d[x];
        }
        for (int i = 0; i < rlist[ep].size(); i++)
        {
            int x = rlist[ep].get(i);
            if (x == edge) continue;
            d2[x] = markback(d, d2, x);
            sum += d2[x] + 1;
        }
        return sum;
    }

    private static int markback(int[] d, int[] d2, int edge)
    {
        //System.out.println("Marking back " + edge);
        if (d2[edge] != -1)
        {
            return d2[edge];
        }
        int ep = s[edge];
        int sum = 0;
        for (int i = 0; i < list[ep].size(); i++)
        {
            int x = list[ep].get(i);
            if (x == edge) continue;
            d[x] = markfwd(d, d2, x);
            sum += d[x];
        }
        for (int i = 0; i < rlist[ep].size(); i++)
        {
            int x = rlist[ep].get(i);
            d2[x] = markback(d, d2, x);
            sum += d2[x] + 1;
        }
        return sum;
    }
}


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

public class C135D
{
    static int[] s, t;
    static ArrayList<Integer>[] list, rlist;
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        s = new int[n-1];
        t = new int[n-1];
        list = new ArrayList[n];
        rlist = new ArrayList[n];
        for (int i = 0; i < n; i++)
        {
            list[i] = new ArrayList<Integer>(1);
            rlist[i] = new ArrayList<Integer>(1);
        }
        for (int i = 0; i < n - 1; i++)
        {
            s[i] = sc.nextInt() - 1;
            t[i] = sc.nextInt() - 1;
            list[s[i]].add(i);
            rlist[t[i]].add(i);
        }
        int[] d = new int[n-1];
        Arrays.fill(d, -1);
        for (int i = 0; i < n - 1; i++)
        {
            d[i] = mark(d, i);
        }
        int[] sum = new int[n];
        int best = n + 1;
        for (int i = 0; i < n-1; i++)
        {
            sum[s[i]] += d[i];
        }
        for (int i = 0; i < n; i++)
        {
            sum[i] += rlist[i].size();
            if (sum[i] < best)
            {
                best = sum[i];
            }
        }
        System.out.println(best);
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < n; i++)
        {
            if (sum[i] == best)
            {
                if (sb.length() != 0) sb.append(" ");
                sb.append(i+1);
            }
        }
        System.out.println(sb.toString());
    }

    private static int mark(int[] d, int edge)
    {
        if (d[edge] != -1)
        {
            return d[edge];
        }
        int ep = t[edge];
        if (list[ep].size() == 0)
        {
            return rlist[ep].size() - 1;
        }
        else
        {
            int sum = 0;
            for (int i = 0; i < list[ep].size(); i++)
            {
                int next = list[ep].get(i);
                d[next] = mark(d, next);
                sum += d[next];
            }
            return sum + rlist[ep].size() - 1;
        }
    }

}