import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class D
{
	 static class Scanner
	    {
	            BufferedReader br;
	            StringTokenizer st;

	            public Scanner()
	            {
	                    br = new BufferedReader(new InputStreamReader(System.in));
	            }

	            public String next()
	            {

	                    while(st == null || !st.hasMoreTokens())
	                    {
	                            try { st = new StringTokenizer(br.readLine()); }
	                            catch(Exception e) { throw new RuntimeException(); }
	                    }
	                    return st.nextToken();
	            }

	            public int nextInt()
	            {
	                    return Integer.parseInt(next());
	            }

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

	            public String nextLine()
	            {
	                    st = null;
	                    try { return br.readLine(); }
	                    catch(Exception e) { throw new RuntimeException(); }
	            }

	            public boolean endLine()
	            {
	                    try
	                    {
	                            String next = br.readLine();
	                            while(next != null && next.trim().isEmpty())
	                                    next = br.readLine();
	                            if(next == null)
	                                    return true;
	                            st = new StringTokenizer(next);
	                            return st.hasMoreTokens();
	                    }
	                    catch(Exception e) { throw new RuntimeException(); }
	            }
	    }

	static class Orden
	{
		int n;
		int desde;

		Orden(int n2, int padre)
		{
			n = n2;
			desde = padre;
		}
	}

	static class Arista
	{
		int otro;
		int desde;

		Arista(int o, int d)
		{
			otro = o;
			desde = d;
		}
	}

	static LinkedList <Orden> ordenes = new LinkedList <Orden> ();
	static Nodo[] nodos;

	static class Nodo
	{
		ArrayList <Arista> aristas = new ArrayList <Arista> ();
		ArrayList <Integer> soluciones = new ArrayList <Integer> ();
		TreeMap <Integer, Integer> dondeAristas = new TreeMap <Integer, Integer> ();
		LinkedList <Arista> porResolver = new LinkedList <Arista> ();
		int resueltos;
		int cuentaTotal;
		int n;

		public Nodo(int i)
		{
			n = i;
		}

		void arreglar()
		{
			int i = 0;
			for(Arista a : aristas)
			{
				soluciones.add(null);
				dondeAristas.put(a.otro, i++);
				porResolver.add(a);
			}
		}

		void resolver(int padre)
		{
			if(resuleto(padre) != -1)
				return;
			Iterator <Arista> it = porResolver.iterator();
			while(it.hasNext())
			{
				Arista a = it.next();
				if(a.otro == padre)
					continue;
				if(nodos[a.otro].resuleto(n) != -1)
				{
					int cuenta = nodos[a.otro].resuleto(n);
					if(a.desde != n)
						cuenta++;
					soluciones.set(dondeAristas.get(a.otro), cuenta);
					cuentaTotal += cuenta;
					resueltos++;
					it.remove();
				}
				else
				{
					ordenes.addFirst(new Orden(n, padre));
					ordenes.addFirst(new Orden(a.otro, n));
					return;
				}
			}
		}

		int resuleto(int padre)
		{
			if(padre == -1 && resueltos == aristas.size())
				return cuentaTotal;
			else if(padre != -1)
			{
				if(resueltos == aristas.size())
					return cuentaTotal - soluciones.get(dondeAristas.get(padre));
				else if(resueltos == aristas.size() - 1 && soluciones.get(dondeAristas.get(padre)) == null)
					return cuentaTotal;
			}
			return -1;
		}
	}

	static int solve(int c)
	{
		Nodo ciudad = nodos[c];
		ordenes.clear();
		ordenes.add(new Orden(c, -1));
		while(!ordenes.isEmpty())
		{
			Orden o = ordenes.poll();
			nodos[o.n].resolver(o.desde);
		}
		return ciudad.resuleto(-1);
	}

	public static void main(String[] args)
	{
		Scanner sc = new Scanner();
		int n = sc.nextInt();
		nodos = new Nodo[n];
		for(int i = 0; i < n; i++)
			nodos[i] = new Nodo(i);
		for(int i = 0; i < n - 1; i++)
		{
			int a = sc.nextInt() - 1;
			int b = sc.nextInt() - 1;
			Arista ab = new Arista(b, a);
			Arista ba = new Arista(a, a);
			nodos[a].aristas.add(ab);
			nodos[b].aristas.add(ba);
		}
		for(int i = 0; i < n; i++)
			nodos[i].arreglar();
		ArrayList <Integer> mejoresAct = new ArrayList <Integer> ();
		int mejor = 100000000;
		for(int i = 0; i < n; i++)
		{
			int count = solve(i);
			if(count < mejor)
			{
				mejor = count;
				mejoresAct.clear();
				mejoresAct.add(i + 1);
			}
			else if(count == mejor)
				mejoresAct.add(i + 1);
		}
		System.out.println(mejor);
		System.out.print(mejoresAct.get(0));
		for(int i = 1; i < mejoresAct.size(); i++)
			System.out.print(" " + mejoresAct.get(i));
		System.out.println();
	}
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class D
{
	 static class Scanner
	    {
	            BufferedReader br;
	            StringTokenizer st;

	            public Scanner()
	            {
	                    br = new BufferedReader(new InputStreamReader(System.in));
	            }

	            public String next()
	            {

	                    while(st == null || !st.hasMoreTokens())
	                    {
	                            try { st = new StringTokenizer(br.readLine()); }
	                            catch(Exception e) { throw new RuntimeException(); }
	                    }
	                    return st.nextToken();
	            }

	            public int nextInt()
	            {
	                    return Integer.parseInt(next());
	            }

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

	            public String nextLine()
	            {
	                    st = null;
	                    try { return br.readLine(); }
	                    catch(Exception e) { throw new RuntimeException(); }
	            }

	            public boolean endLine()
	            {
	                    try
	                    {
	                            String next = br.readLine();
	                            while(next != null && next.trim().isEmpty())
	                                    next = br.readLine();
	                            if(next == null)
	                                    return true;
	                            st = new StringTokenizer(next);
	                            return st.hasMoreTokens();
	                    }
	                    catch(Exception e) { throw new RuntimeException(); }
	            }
	    }

	static class Orden
	{
		int n;
		int desde;

		Orden(int n2, int padre)
		{
			n = n2;
			desde = padre;
		}
	}

	static class Arista
	{
		int otro;
		int desde;

		Arista(int o, int d)
		{
			otro = o;
			desde = d;
		}
	}

	static LinkedList <Orden> ordenes = new LinkedList <Orden> ();
	static Nodo[] nodos;

	static class Nodo
	{
		ArrayList <Arista> aristas = new ArrayList <Arista> ();
		ArrayList <Integer> soluciones = new ArrayList <Integer> ();
		TreeMap <Integer, Integer> dondeAristas = new TreeMap <Integer, Integer> ();
		ArrayList <Arista> porResolver = new ArrayList <Arista> ();
		int resueltos;
		int cuentaTotal;
		int n;

		public Nodo(int i)
		{
			n = i;
		}

		void arreglar()
		{
			int i = 0;
			for(Arista a : aristas)
			{
				soluciones.add(null);
				dondeAristas.put(a.otro, i++);
				porResolver.add(a);
			}
		}

		void resolver(int padre)
		{
			if(resuleto(padre) != -1)
				return;
			Iterator <Arista> it = porResolver.iterator();
			while(it.hasNext())
			{
				Arista a = it.next();
				if(a.otro == padre)
					continue;
				if(nodos[a.otro].resuleto(n) != -1)
				{
					int cuenta = nodos[a.otro].resuleto(n);
					if(a.desde != n)
						cuenta++;
					soluciones.set(dondeAristas.get(a.otro), cuenta);
					cuentaTotal += cuenta;
					resueltos++;
					it.remove();
				}
				else
				{
					ordenes.addFirst(new Orden(n, padre));
					ordenes.addFirst(new Orden(a.otro, n));
					return;
				}
			}
		}

		int resuleto(int padre)
		{
			if(padre == -1 && resueltos == aristas.size())
				return cuentaTotal;
			else if(padre != -1)
			{
				if(resueltos == aristas.size())
					return cuentaTotal - soluciones.get(dondeAristas.get(padre));
				else if(resueltos == aristas.size() - 1 && soluciones.get(dondeAristas.get(padre)) == null)
					return cuentaTotal;
			}
			return -1;
		}
	}

	static int solve(int c)
	{
		Nodo ciudad = nodos[c];
		ordenes.clear();
		ordenes.add(new Orden(c, -1));
		while(!ordenes.isEmpty())
		{
			Orden o = ordenes.poll();
			nodos[o.n].resolver(o.desde);
		}
		return ciudad.resuleto(-1);
	}

	public static void main(String[] args)
	{
		Scanner sc = new Scanner();
		int n = sc.nextInt();
		nodos = new Nodo[n];
		for(int i = 0; i < n; i++)
			nodos[i] = new Nodo(i);
		for(int i = 0; i < n - 1; i++)
		{
			int a = sc.nextInt() - 1;
			int b = sc.nextInt() - 1;
			Arista ab = new Arista(b, a);
			Arista ba = new Arista(a, a);
			nodos[a].aristas.add(ab);
			nodos[b].aristas.add(ba);
		}
		for(int i = 0; i < n; i++)
			nodos[i].arreglar();
		ArrayList <Integer> mejoresAct = new ArrayList <Integer> ();
		int mejor = 100000000;
		for(int i = 0; i < n; i++)
		{
			int count = solve(i);
			if(count < mejor)
			{
				mejor = count;
				mejoresAct.clear();
				mejoresAct.add(i + 1);
			}
			else if(count == mejor)
				mejoresAct.add(i + 1);
		}
		System.out.println(mejor);
		System.out.print(mejoresAct.get(0));
		for(int i = 1; i < mejoresAct.size(); i++)
			System.out.print(" " + mejoresAct.get(i));
		System.out.println();
	}
}


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

public class Main {

   // static class Scanner {
   // StreamTokenizer in;
   // boolean forceMode = false;
   //
   // Scanner(InputStream is, String codePage, boolean forceMode) {
   // in = new StreamTokenizer(new BufferedReader(new InputStreamReader(is)));
   // if (!forceMode) {
   // in.resetSyntax();
   // in.wordChars(33, 255);
   // in.whitespaceChars(0, 32);
   // }
   // }
   //
   // Scanner(InputStream is, String codePage) {
   // in = new StreamTokenizer(new BufferedReader(new InputStreamReader(is)));
   // if (!forceMode) {
   // in.resetSyntax();
   // in.wordChars(33, 255);
   // in.whitespaceChars(0, 32);
   // }
   // }
   //
   // String next() {
   // try {
   // in.nextToken();
   // return in.sval;
   // } catch (Exception e) {
   // throw new Error();
   // }
   // }
   //
   // int nextInt() {
   // if (forceMode) {
   // try {
   // in.nextToken();
   // return (int) in.nval;
   // } catch (Exception e) {
   // throw new Error();
   // }
   // } else {
   // return Integer.parseInt(next());
   // }
   // }
   //
   // long nextLong() {
   // if (forceMode) {
   // throw new Error("No long at force mod!");
   // } else {
   // return Long.parseLong(next());
   // }
   //
   // }
   //
   // double nextDouble() {
   // if (forceMode) {
   // try {
   // in.nextToken();
   // return in.nval;
   // } catch (Exception e) {
   // throw new Error();
   // }
   // } else {
   // return Double.parseDouble(next());
   // }
   // }
   // }

   static class Assertion {
      static void checkRE(boolean e) {
         if (!e) {
            throw new Error();
         }
      }

      static void checkTL(boolean e) {
         if (!e) {
            int idx = 1;
            while (idx > 0) {
               idx++;
            }
         }
      }
   }

   Scanner in;
   PrintWriter out;

   class Link {
      Node node;
      boolean isDirect;

      public Link(Node node, boolean direct) {
         this.node = node;
         this.isDirect = direct;
      }
   }

   class Node {
      int f;
      int idx;
      ArrayList<Link> links = new ArrayList<Main.Link>();

      boolean wasUsed;

      public Node(int idx) {
         this.idx = idx;
      }

      void add(Node link, boolean direct) {
         links.add(new Link(link, direct));
      }

      void dfs() {
         this.wasUsed = true;
         for (Link next : links) {
            if (!next.node.wasUsed) {
               next.node.dfs();
               if (!next.isDirect) {
                  f += next.node.f + 1;
               } else {
                  f += next.node.f;
               }
            }
         }
      }

      void recalc() {
         this.wasUsed = true;
         for (Link next : links) {
            if (!next.node.wasUsed) {
               if (next.isDirect) {
                  next.node.f = this.f + 1;
               } else {
                  next.node.f = this.f - 1;
               }
               next.node.recalc();
            }
         }
      }
   }

   void solve() {
      int nNodes = in.nextInt();
      Node nodes[] = new Node[1 + nNodes];
      for (int i = 0; i < nodes.length; i++) {
         nodes[i] = new Node(i);
      }
      for (int i = 1; i <= nNodes - 1; i++) {
         Node from = nodes[in.nextInt()];
         Node to = nodes[in.nextInt()];
         from.add(to, true);
         to.add(from, false);
      }
      nodes[1].dfs();
      for (int i = 1; i < nodes.length; i++) {
         nodes[i].wasUsed = false;
      }
      nodes[1].recalc();
      int min = Integer.MAX_VALUE;
      for (int i = 1; i < nodes.length; i++) {
         min = Math.min(min, nodes[i].f);
      }
      out.println(min);
      for (int i = 1; i < nodes.length; i++) {
         if (nodes[i].f == min) {
            out.print(nodes[i].idx + " ");
         }
      }
   }

   final static String fileName = "";

   void run() {
      // try {
      // in = new Scanner(new FileInputStream(fileName + ".in"), "ISO-8859-1");
      // out = new PrintWriter(fileName + ".out", "ISO-8859-1");
      // } catch (FileNotFoundException e) {
      // throw new Error(e);
      //
      // } catch (UnsupportedEncodingException e) {
      // throw new Error(e);
      // }
      in = new Scanner(System.in);
      out = new PrintWriter(System.out);
      try {
         solve();
      } catch (Exception e) {
         throw new Error(e);
      } finally {
         out.close();
      }
   }

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


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

public class D
{
   public static void main(String[] args)
   {
      new D(new FastScanner());
   }

   Graph g;
   int[] upCost;
   int[] downCost;
   int go(int i, int par, int dd, int uu)
   {
      upCost[i] = uu;
      downCost[i] = dd;

      int res = 0;
      for (Edge e : g.adj[i])
      {
         if (e.j == par) continue;
         int ndd = dd+e.w;
         int nuu = uu+1-e.w;
         res += e.w+go(e.j, i, ndd, nuu);
      }
      return res;
   }

   public D(FastScanner in)
   {
      g = new Graph(in.nextInt());
      int M = g.N-1;
      while (M-->0)
         g.add(in.nextInt()-1,in.nextInt()-1);

      upCost = new int[g.N];
      downCost = new int[g.N];

      int oo = 987654321;
      int[] score = new int[g.N];
      int totalScore = go(0, -1, 0, 0);
      int bestScore = oo;
      for (int i=0; i<g.N; i++)
         bestScore = Math.min(bestScore, score[i] = totalScore-downCost[i]+upCost[i]);

      //System.out.println(Arrays.toString(downCost));
      //System.out.println(Arrays.toString(upCost));
      //System.out.println(Arrays.toString(score));

      StringBuilder sb = new StringBuilder();
      for (int i=0; i<g.N; i++)
         if (score[i] == bestScore)
         {
            sb.append(i+1);
            sb.append(' ');
         }
      System.out.println(bestScore);
      System.out.println(sb.toString().trim());
   }
}

class Graph
{
   int N;
   ArrayList<Edge>[] adj;
   public Graph(int n)
   {
      adj = new ArrayList[N=n];
      for (int i=0; i<N; i++)
         adj[i] = new ArrayList<Edge>();
   }

   void add(int i, int j)
   {
      adj[i].add(new Edge(j, 0));
      adj[j].add(new Edge(i, 1));
   }
}

class Edge
{
   int j, w;
   public Edge(int jj, int ww)
   {
      j=jj; w=ww;
   }
}

class FastScanner{
   private InputStream stream;
   private byte[] buf = new byte[1024];
   private int curChar;
   private int numChars;

   public FastScanner()
   {
      stream = System.in;
   }

   int read()
   {
      if (numChars == -1)
         throw new InputMismatchException();
      if (curChar >= numChars){
         curChar = 0;
         try{
            numChars = stream.read(buf);
         } catch (IOException e) {
            throw new InputMismatchException();
         }
         if (numChars <= 0)
            return -1;
      }
      return buf[curChar++];
   }

   boolean isSpaceChar(int c)
   {
      return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
   }

   boolean isEndline(int c)
   {
      return c=='\n'||c=='\r'||c==-1;
   }

   int nextInt()
   {
      return Integer.parseInt(next());
   }

   long nextLong()
   {
      return Long.parseLong(next());
   }

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

   String next(){
      int c = read();
      while (isSpaceChar(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isSpaceChar(c));
      return res.toString();
   }

   String nextLine(){
      int c = read();
      while (isEndline(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isEndline(c));
      return res.toString();
   }
}


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

public class D
{
   public static void main(String[] args)
   {
      new D(new FastScanner());
   }

   Graph g;

   int[][] dp;
   int go(int i, int p)
   {
      if (dp[i][p] != -1)
         return dp[i][p];

      int res = 0;
      for (int id=0; id<g.adj[i].size(); id++)
      {
         Edge e = g.adj[i].get(id);
         if (id != p)
            res += e.c + go(e.j, g.mmp[e.j].get(i));
      }

      //System.out.printf("dp[%d][%d] = %d%n", i, g.adj[i].get(p).j, res);
      return dp[i][p] = res;
   }

   public D(FastScanner in)
   {
      g = new Graph(in.nextInt());
      int M = g.N-1;
      while (M-->0)
         g.add(in.nextInt()-1,in.nextInt()-1);
      dp = new int[g.N][];
      for (int i=0; i<g.N; i++)
         Arrays.fill(dp[i] = new int[g.adj[i].size()+1], -1);

      int best = g.N+5;
      int[] score = new int[g.N];
      for (int i=0; i<g.N; i++)
      {
         if (g.adj[i].size() > 1)
         {
            int j = g.adj[i].get(0).j;
            int r1 = go(i, 0);
            int r2 = g.adj[i].get(0).c+go(j, g.mmp[j].get(i));
            score[i] = r1+r2;
            //System.out.printf("%d = %d = %d + %d%n", i, score[i], r1, r2);
         }
         else
         {
            score[i] = go(i, g.adj[i].size());
            //System.out.printf("%d = %d%n", i, score[i]);
         }

         if (best > score[i])
            best = score[i];
      }

      PrintWriter out = new PrintWriter(System.out);
      ArrayList<Integer> res = new ArrayList<Integer>();
      for (int i=0; i<g.N; i++)
         if (best == score[i])
            res.add(i+1);
      out.println(best);
      StringBuilder sb = new StringBuilder();
      for (int v : res)
      {
         sb.append(v);
         sb.append(' ');
      }
      out.println(sb.toString().trim());
      out.close();
   }
}

class Graph
{
   int N;
   ArrayList<Edge>[] adj;
   HashMap<Integer,Integer>[] mmp;

   public Graph(int n)
   {
      adj = new ArrayList[N=n];
      mmp = new HashMap[N];
      for (int i=0; i<N; i++)
      {
         adj[i] = new ArrayList<Edge>();
         mmp[i] = new HashMap<Integer,Integer>();
      }
   }

   void add1(int i, int j, int c)
   {
      mmp[i].put(j, adj[i].size());
      adj[i].add(new Edge(j, c));
   }

   void add(int i, int j)
   {
      add1(i,j,0);
      add1(j,i,1);
   }
}

class Edge
{
   int j, c;
   public Edge(int jj, int cc)
   {
      j=jj; c=cc;
   }
}

class FastScanner{
   private InputStream stream;
   private byte[] buf = new byte[1024];
   private int curChar;
   private int numChars;

   public FastScanner()
   {
      stream = System.in;
   }

   int read()
   {
      if (numChars == -1)
         throw new InputMismatchException();
      if (curChar >= numChars){
         curChar = 0;
         try{
            numChars = stream.read(buf);
         } catch (IOException e) {
            throw new InputMismatchException();
         }
         if (numChars <= 0)
            return -1;
      }
      return buf[curChar++];
   }

   boolean isSpaceChar(int c)
   {
      return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
   }

   boolean isEndline(int c)
   {
      return c=='\n'||c=='\r'||c==-1;
   }

   int nextInt()
   {
      return Integer.parseInt(next());
   }

   long nextLong()
   {
      return Long.parseLong(next());
   }

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

   String next(){
      int c = read();
      while (isSpaceChar(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isSpaceChar(c));
      return res.toString();
   }

   String nextLine(){
      int c = read();
      while (isEndline(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isEndline(c));
      return res.toString();
   }
}


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

public class D
{
   public static void main(String[] args)
   {
      new D(new FastScanner());
   }

   Graph g;

   int[][] dp;
   int go(int i, int p)
   {
      if (dp[i][p] != -1)
         return dp[i][p];

      int res = 0;

      int id = 0;
      for (Edge e : g.adj[i])
      {
         if (id != p)
         {
            int rr = e.c + go(e.j, g.mmp[e.j].get(i));
            res += rr;
         }
         id++;
      }

      //System.out.printf("dp[%d][%d] = %d%n", i, g.adj[i].get(p).j, res);
      return dp[i][p] = res;
   }

   public D(FastScanner in)
   {
      g = new Graph(in.nextInt());
      int M = g.N-1;
      while (M-->0)
         g.add(in.nextInt()-1,in.nextInt()-1);
      dp = new int[g.N][];
      for (int i=0; i<g.N; i++)
         Arrays.fill(dp[i] = new int[g.adj[i].size()+1], -1);

      int best = g.N+5;
      int[] score = new int[g.N];
      for (int i=0; i<g.N; i++)
      {
         if (g.adj[i].size() > 1)
         {
            int j = g.adj[i].get(0).j;
            int r1 = go(i, 0);
            int r2 = g.adj[i].get(0).c+go(j, g.mmp[j].get(i));
            score[i] = r1+r2;
            //System.out.printf("%d = %d = %d + %d%n", i, score[i], r1, r2);
         }
         else
         {
            score[i] = go(i, g.adj[i].size());
            //System.out.printf("%d = %d%n", i, score[i]);
         }

         if (best > score[i])
            best = score[i];
      }

      PrintWriter out = new PrintWriter(System.out);
      ArrayList<Integer> res = new ArrayList<Integer>();
      for (int i=0; i<g.N; i++)
         if (best == score[i])
            res.add(i+1);
      out.println(best);
      StringBuilder sb = new StringBuilder();
      for (int v : res)
      {
         sb.append(v);
         sb.append(' ');
      }
      out.println(sb.toString().trim());
      out.close();
   }
}

class Graph
{
   int N;
   ArrayList<Edge>[] adj;
   HashMap<Integer,Integer>[] mmp;

   public Graph(int n)
   {
      adj = new ArrayList[N=n];
      mmp = new HashMap[N];
      for (int i=0; i<N; i++)
      {
         adj[i] = new ArrayList<Edge>();
         mmp[i] = new HashMap<Integer,Integer>();
      }
   }

   void add1(int i, int j, int c)
   {
      mmp[i].put(j, adj[i].size());
      adj[i].add(new Edge(j, c));
   }

   void add(int i, int j)
   {
      add1(i,j,0);
      add1(j,i,1);
   }
}

class Edge
{
   int j, c;
   public Edge(int jj, int cc)
   {
      j=jj; c=cc;
   }
}

class FastScanner{
   private InputStream stream;
   private byte[] buf = new byte[1024];
   private int curChar;
   private int numChars;

   public FastScanner()
   {
      stream = System.in;
   }

   int read()
   {
      if (numChars == -1)
         throw new InputMismatchException();
      if (curChar >= numChars){
         curChar = 0;
         try{
            numChars = stream.read(buf);
         } catch (IOException e) {
            throw new InputMismatchException();
         }
         if (numChars <= 0)
            return -1;
      }
      return buf[curChar++];
   }

   boolean isSpaceChar(int c)
   {
      return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
   }

   boolean isEndline(int c)
   {
      return c=='\n'||c=='\r'||c==-1;
   }

   int nextInt()
   {
      return Integer.parseInt(next());
   }

   long nextLong()
   {
      return Long.parseLong(next());
   }

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

   String next(){
      int c = read();
      while (isSpaceChar(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isSpaceChar(c));
      return res.toString();
   }

   String nextLine(){
      int c = read();
      while (isEndline(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isEndline(c));
      return res.toString();
   }
}


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

public class D
{
   public static void main(String[] args)
   {
      new D(new FastScanner());
   }

   Graph g;

   int[][] dp;
   int go(int i, int p)
   {
      if (dp[i][p] != -1)
         return dp[i][p];

      int res = 0;

      int id = 0;
      for (Edge e : g.adj[i])
      {
         if (id != p)
         {
            int rr = e.c + go(e.j, g.mmp[e.j].get(i));
            res += rr;
         }
         id++;
      }

      //System.out.printf("dp[%d][%d] = %d%n", i, g.adj[i].get(p).j, res);
      return dp[i][p] = res;
   }

   public D(FastScanner in)
   {
      g = new Graph(in.nextInt());
      int M = g.N-1;
      while (M-->0)
         g.add(in.nextInt()-1,in.nextInt()-1);
      dp = new int[g.N][];
      for (int i=0; i<g.N; i++)
         Arrays.fill(dp[i] = new int[g.adj[i].size()+1], -1);

      int best = g.N+5;
      int[] score = new int[g.N];
      for (int i=0; i<g.N; i++)
      {
         if (g.adj[i].size() > 1)
         {
            int j = g.adj[i].get(0).j;
            int r1 = go(i, 0);
            int r2 = g.adj[i].get(0).c+go(j, g.mmp[j].get(i));
            score[i] = r1+r2;
            //System.out.printf("%d = %d = %d + %d%n", i, score[i], r1, r2);
         }
         else
         {
            score[i] = go(i, g.adj[i].size());
            //System.out.printf("%d = %d%n", i, score[i]);
         }

         if (best > score[i])
            best = score[i];
      }

      PrintWriter out = new PrintWriter(System.out);
      ArrayList<Integer> res = new ArrayList<Integer>();
      for (int i=0; i<g.N; i++)
         if (best == score[i])
            res.add(i+1);
      out.println(best);
      StringBuilder sb = new StringBuilder();
      for (int v : res)
      {
         sb.append(v);
         sb.append(' ');
      }
      out.println(sb.toString().trim());
      out.close();
   }
}

class Graph
{
   int N;
   ArrayList<Edge>[] adj;
   TreeMap<Integer,Integer>[] mmp;

   public Graph(int n)
   {
      adj = new ArrayList[N=n];
      mmp = new TreeMap[N];
      for (int i=0; i<N; i++)
      {
         adj[i] = new ArrayList<Edge>();
         mmp[i] = new TreeMap<Integer,Integer>();
      }
   }

   void add1(int i, int j, int c)
   {
      mmp[i].put(j, adj[i].size());
      adj[i].add(new Edge(j, c));
   }

   void add(int i, int j)
   {
      add1(i,j,0);
      add1(j,i,1);
   }
}

class Edge
{
   int j, c;
   public Edge(int jj, int cc)
   {
      j=jj; c=cc;
   }
}

class FastScanner{
   private InputStream stream;
   private byte[] buf = new byte[1024];
   private int curChar;
   private int numChars;

   public FastScanner()
   {
      stream = System.in;
   }

   int read()
   {
      if (numChars == -1)
         throw new InputMismatchException();
      if (curChar >= numChars){
         curChar = 0;
         try{
            numChars = stream.read(buf);
         } catch (IOException e) {
            throw new InputMismatchException();
         }
         if (numChars <= 0)
            return -1;
      }
      return buf[curChar++];
   }

   boolean isSpaceChar(int c)
   {
      return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
   }

   boolean isEndline(int c)
   {
      return c=='\n'||c=='\r'||c==-1;
   }

   int nextInt()
   {
      return Integer.parseInt(next());
   }

   long nextLong()
   {
      return Long.parseLong(next());
   }

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

   String next(){
      int c = read();
      while (isSpaceChar(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isSpaceChar(c));
      return res.toString();
   }

   String nextLine(){
      int c = read();
      while (isEndline(c))
         c = read();
      StringBuilder res = new StringBuilder();
      do{
         res.appendCodePoint(c);
         c = read();
      }while(!isEndline(c));
      return res.toString();
   }
}


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

public class Round135Div2D {
	public static void main(String[] args) throws IOException
	{
		BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		st = new StringTokenizer(rd.readLine());
		n = Integer.parseInt(st.nextToken());
		G = new ArrayList[n];
		for(int i=0; i<n; i++) G[i] = new ArrayList<Integer>();
		D = new ArrayList[n];
		for(int i=0; i<n; i++) D[i] = new ArrayList<Integer>();
		for(int i=0; i<n-1; i++){
			st = new StringTokenizer(rd.readLine());
			int a = Integer.parseInt(st.nextToken()), b = Integer.parseInt(st.nextToken());
			a--; b--;
			G[a].add(b);
			G[b].add(a);
			D[a].add(1);
			D[b].add(-1);
		}
		depth = new int[n];
		parent = new int[n];
		minInv = new int[n];
		minInWay = new int[n];
		way = new int[n];
		s = new int[n];
		dfs(root, -1, 0, 0);
		min_inv(0);
		for(int i=0; i<n; i++){
			way[i] = minInWay[i];
			minInWay[i] = depth[i] - minInWay[i];
		}
		for(int i=0; i<G[root].size(); i++){
			int t = G[root].get(i);
			dfs2(t, root, t);
		}
		sum = new int[n];
		for(int i=0; i<G[root].size(); i++) {
			findSums(G[root].get(i), root);
		}
		direct = new boolean[n];
		for(int i=0; i<G[root].size(); i++){
			int t  = G[root].get(i);
			if(D[root].get(i)==1) direct[t] = true;
		}
		int minimal = n;
		for(int i=0; i<n; i++){
			minimal = Math.min(minimal, cur_inv(i));
		}

		pw.println(minimal);
		for(int i=0; i<n; i++) if(minimal==cur_inv(i)) pw.print((i+1)+" ");
		pw.println();
		pw.flush();
	}

	static int min_inv(int v){
		int par = parent[v];
		int s = 0;
		for(int i=0; i<G[v].size(); i++){
			int t = G[v].get(i);
			if(t!=par){
				s += min_inv(t);
				if(D[v].get(i)!=1) s++;
			}
		}
		minInv[v] = s;
		return s;
	}

	static void dfs(int current, int par, int dep, int inv){
		depth[current] = dep;
		parent[current] = par;
		minInWay[current] = inv;
		for(int i=0; i<G[current].size(); i++){
			int t = G[current].get(i);
			if(t!=par){
				int inv1 = inv;
				if(D[current].get(i)!=1) inv1++;
				dfs(t, current, dep+1, inv1);
			}
		}
	}

	static void dfs2(int cur, int par, int val){
		s[cur] = val;
		for(int i=0; i<G[cur].size(); i++){
			int t = G[cur].get(i);
			if(t==par) continue;
			dfs2(t, cur, val);
		}
	}

	static int cur_inv(int v){
		if(v==root){
			return minInv[v];
		}
		return minInWay[v] + minInv[root] - way[v];
	}

	static void findSums(int v, int par){
		if(par==root) sum[v] = minInv[v];
		else sum[v] = minInv[v] + sum[par];
		for(int i=0; i<G[v].size(); i++){
			int t = G[v].get(i);
			if(t==par) continue;
			findSums(t, v);
		}
	}

	static int[] sum;

	static boolean[] direct;

	static int[] s;

	static int[] minInv, minInWay, way;

	static int[] depth, parent;

	static ArrayList<Integer>[] G, D;

	static int n, root = 0;

	static StringTokenizer st;

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;

public class D {
    static LinkedList<edge> E[];
    static boolean[] visited;

    public static int dfs(int current) {
        if (visited[current])
            return 0;
        visited[current] = true;
        int ans = 0;
        for (edge e : E[current]) {
            if (!e.t && !visited[e.x])
                ans++;
            ans += dfs(e.x);
        }
        return ans;
    }

    public static void main(String[] args) throws NumberFormatException,
            IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(in.readLine());
        E = new LinkedList[n];
        visited = new boolean[n];
        for (int i = 0; i < n; i++)
            E[i] = new LinkedList<edge>();
        for (int i = 1; i < n; i++) {
            String[] S = in.readLine().split(" ");
            int x = Integer.parseInt(S[0]) - 1;
            int y = Integer.parseInt(S[1]) - 1;
            E[x].add(new edge(y, true));
            E[y].add(new edge(x, false));
        }
        int[] best = new int[n];
        best[0] = dfs(0);
        visited = new boolean[n];
        Queue<Integer> Q = new LinkedList<Integer>();
        Q.add(0);
        while (!Q.isEmpty()) {
            int x = Q.poll();
            visited[x] = true;
            for (edge e : E[x]) {
                if (visited[e.x])
                    continue;
                if (e.t)
                    best[e.x] = best[x] + 1;
                else
                    best[e.x] = best[x] - 1;
                Q.add(e.x);
            }
        }
        int ans = n;
        for (int i = 0; i < n; i++)
            ans = Math.min(ans, best[i]);
        System.out.println(ans);
        for (int i = 0; i < n; i++)
            if (best[i] == ans)
                System.out.print((i + 1) + " ");
        System.out.println();
    }
}

class edge {
    int x;
    boolean t;

    public edge(int i, boolean k) {
        x = i;
        t = k;
    }
}


import com.sun.org.apache.bcel.internal.classfile.InnerClass;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * 4 6
 * 1 2
 * 1 3
 * 1 4
 * 2 3
 * 2 4
 * 3 4
 *
 *
 *
 *
 *
 *
 * @author pttrung
 */
public class D {

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File("output.txt")));
        int n = in.nextInt();
        int[] count = new int[n];
        ArrayList<Integer>[] list = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            count[i] = -1;
            list[i] = new ArrayList();
        }
        for (int i = 0; i < n - 1; i++) {
            int a = in.nextInt() - 1;
            int b = in.nextInt() - 1;
            list[a].add(b);
        }
        for(int i = 0; i < n; i++){
            if(count[i] == -1){
                dfs(i,list,count);
            }
        }
        int max = 0;
        for(int i  = 0; i < n; i++){
            max = Math.max(count[i] , max);
        }
        out.println((n - max));
        for(int i= 0; i < n ; i++){
            if(count[i] == max){
                out.print((i + 1) + " ");
            }
        }
        out.close();
    }

    public static int dfs(int node , ArrayList<Integer> []list , int []count){
        if(count[node] != -1){
            return count[node];
        }
        count[node] = 1;
        for(int i : list[node]){
            count[node]+= dfs(i,list, count);
        }
        return count[node];
    }

    public static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        public void update(int index, int value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public int get(int index) {
            int result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val;
        } else {
            return val * (val * a);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import com.sun.org.apache.bcel.internal.classfile.InnerClass;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * 4 6
 * 1 2
 * 1 3
 * 1 4
 * 2 3
 * 2 4
 * 3 4
 *
 *
 *
 *
 *
 *
 * @author pttrung
 */
public class D {

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File("output.txt")));
        int n = in.nextInt();
        int[] count = new int[n];
        int []pa = new int[n];
        ArrayList<Node>[] list = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            count[i] = -1;
            pa[i] = i;
            list[i] = new ArrayList();
        }
        for (int i = 0; i < n - 1; i++) {
            int a = in.nextInt() - 1;
            int b = in.nextInt() - 1;
            pa[b] = pa[a];
            list[a].add(new Node(false, b));
            list[b].add(new Node(true , a));
        }
        boolean []check = new boolean [n];
        int min = Integer.MAX_VALUE;
        ArrayList<Integer> result = new ArrayList();
        for(int i = 0; i < n; i++){
            int node = i;
            while(node != pa[node]){
                node = pa[node];
            }
            if(!check[node]){
              //  System.out.println(node);
                check[node] = true;
                int val = dfs(node, -1, list);
                if(val < min){
                    min = val;
                    result.clear();
                    result.add(node);
                }else if(val == min){
                    result.add(node);
                }
            }

        }
        out.println(min);
        for(int i : result){
            out.print((i + 1) + " ");
        }
        out.close();
    }

    public static int dfs(int node,int pa, ArrayList<Node>[] list) {
        //System.out.println("Node " + node + " " + pa);
        int result  = 0;
        for (Node i : list[node]) {
            if(i.node != pa){
                if(i.reverse){
   //                 System.out.println(node + " " + i.node + " " + pa) ;
                    result++;
                }
                result += dfs(i.node, node, list);
            }
        }
        return result;
    }

    public static class Node {
        boolean reverse;
        int node;

        public Node(boolean reverse, int node) {
            this.reverse = reverse;
            this.node = node;
        }

    }

    public static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        public void update(int index, int value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public int get(int index) {
            int result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val;
        } else {
            return val * (val * a);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


import com.sun.org.apache.bcel.internal.classfile.InnerClass;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

/**
 * 4 6
 * 1 2
 * 1 3
 * 1 4
 * 2 3
 * 2 4
 * 3 4
 *
 *
 *
 *
 *
 *
 * @author pttrung
 */
public class D {

    public static int[] num, pa;

    public static void main(String[] args) {
        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        // PrintWriter out = new PrintWriter(new FileOutputStream(new File("output.txt")));
        int n = in.nextInt();
        pa = new int[n];
        num = new int[n];
        ArrayList<Node>[] list = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            pa[i] = i;
            list[i] = new ArrayList();
        }
        for (int i = 0; i < n - 1; i++) {
            int a = in.nextInt() - 1;
            int b = in.nextInt() - 1;
            pa[b] = pa[a];
            list[a].add(new Node(false, b));
            list[b].add(new Node(true, a));
        }
        dfs(0, -1, list);
        dfs2(0, -1, list);
        int min = Integer.MAX_VALUE;
        ArrayList<Integer> result = new ArrayList();
        for (int i = 0; i < n; i++) {
            if (min > n - 1 - num[i]) {
                min = (n - 1 - num[i]);
                result.clear();
                result.add((i + 1));
            }else if(min == n - 1 - num[i]){
                result.add((i + 1));
            }
        }
        out.println(min);
        for(int i : result){
            out.print(i + " ");
        }

        out.close();
    }

    public static int dfs(int node, int p, ArrayList<Node>[] list) {
        int result = 0;
        pa[node] = p;
        for (Node next : list[node]) {
            if (next.node != p) {
                result += dfs(next.node, node, list);
                if (!next.reverse) {
                    result++;
                }

            }
        }
        return num[node] = result;
    }

    public static void dfs2(int node, int p, ArrayList<Node>[] list) {
        for (Node next : list[node]) {
            if (next.node != p) {
                num[next.node] += (num[node] - num[next.node]);
                if (!next.reverse) {
                    num[next.node]--;
                } else {
                    num[next.node]++;
                }
                dfs2(next.node , node, list);

            }
        }
    }

    public static class Node {

        boolean reverse;
        int node;

        public Node(boolean reverse, int node) {
            this.reverse = reverse;
            this.node = node;
        }
    }

    public static class FT {

        int[] data;

        FT(int n) {
            data = new int[n];
        }

        public void update(int index, int value) {
            while (index < data.length) {
                data[index] += value;
                index += (index & (-index));
            }
        }

        public int get(int index) {
            int result = 0;
            while (index > 0) {
                result += data[index];
                index -= (index & (-index));
            }
            return result;

        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long pow(long a, long b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val;
        } else {
            return val * (val * a);
        }
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() {
            // System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


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

public class D {

	LinkedList<Integer>[] graph;
	int[] score;
	int toRootTot, best;
	boolean[] visited;

	public void solve() throws Exception {

		int n = nextInt();
		graph = new LinkedList[n];
		for (int i=0; i<n; ++i) graph[i] = new LinkedList<Integer>();
		for (int i=0; i<n-1; ++i) {
			int f = nextInt()-1, t = nextInt()-1;
			graph[f].addLast(t);
			graph[t].addLast(-f);
		}

		score = new int[n];
		visited = new boolean[n];
		dfs(0,0,0);

		println(best+toRootTot);
		for (int i=0; i<n; ++i) if (score[i]==best) print((i+1)+" ");

	}

	void dfs(int v, int fromCnt, int toCnt) {
		if (visited[v]) return;
		visited[v] = true;
		for (int s: graph[v]) if (!visited[abs(s)]) {
			if (s<0) {
				score[-s] += fromCnt;
				score[-s] -= toCnt+1;
				toRootTot++;
				best = min(best, score[-s]);
				dfs(-s, fromCnt, toCnt+1);
			} else {
				score[s] += fromCnt+1;
				score[s] -= toCnt;
				best = min(best, score[s]);
				dfs(s, fromCnt+1, toCnt);
			}
		}
	}

	////////////////////////////////////////////////////////////////////////////

	boolean showDebug = true;
	static boolean useFiles = false;
	static String inFile = "input.txt";
	static String outFile = "output.txt";

	double EPS = 1e-7;
	int INF = Integer.MAX_VALUE;
	long INFL = Long.MAX_VALUE;
	double INFD = Double.MAX_VALUE;

	int absPos(int num) {
		return num<0 ? 0:num;
	}
	long absPos(long num) {
		return num<0 ? 0:num;
	}
	double absPos(double num) {
		return num<0 ? 0:num;
	}

	int min(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	int max(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	long minL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	long maxL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	double minD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	double maxD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}

	long sumArr(int[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	long sumArr(long[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	double sumArr(double[] arr) {
		double res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}

	long partsFitCnt(long partSize, long wholeSize) {
		return (partSize+wholeSize-1)/partSize;
	}

	boolean odd(long num) {
		return (num&1)==1;
	}

	boolean hasBit(int num, int pos) {
		return (num&(1<<pos))>0;
	}

	boolean isLetter(char c) {
		return (c>='a' && c<='z') || (c>='A' && c<='Z');
	}
	boolean isLowercase(char c) {
		return (c>='a' && c<='z');
	}
	boolean isUppercase(char c) {
		return (c>='A' && c<='Z');
	}
	boolean isDigit(char c) {
		return (c>='0' && c<='9');
	}

	boolean charIn(String chars, String s) {
		if (s==null) return false;
		if (chars==null || chars.equals("")) return true;
		for (int i=0; i<s.length(); ++i)
			for (int j=0; j<chars.length(); ++j)
				if (chars.charAt(j)==s.charAt(i)) return true;
		return false;
	}

	String stringn(String s, int n) {
		if (n<1 || s==null) return "";
		StringBuilder sb = new StringBuilder(s.length()*n);
		for (int i=0; i<n; ++i) sb.append(s);
		return sb.toString();
	}
	String str(Object o) {
		if (o==null) return "";
		return o.toString();
	}

	long timer = System.currentTimeMillis();
	void startTimer() {
		timer = System.currentTimeMillis();
	}
	void stopTimer() {
		System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
	}

	static class InputReader {
		private byte[] buf;
		private int bufPos = 0, bufLim = -1;
		private InputStream stream;
		public InputReader(InputStream stream, int size) {
			buf = new byte[size];
			this.stream = stream;
		}
		private void fillBuf() throws IOException {
			bufLim = stream.read(buf);
			bufPos = 0;
		}
		char read() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return (char)buf[bufPos++];
		}
		boolean hasInput() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return bufPos<bufLim;
		}
	}

	static InputReader inputReader;
	static BufferedWriter outputWriter;

	char nextChar() throws IOException {
		return inputReader.read();
	}
	char nextNonWhitespaceChar() throws IOException {
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		return c;
	}
	String nextWord() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c>' ') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	String nextLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c!='\n' && c!='\r') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	int nextInt() throws IOException {
		int r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r=c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10;
			r+=c-48;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	long nextLong() throws IOException {
		long r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r = c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10L;
			r+=c-48L;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextWord());
	}
	int[] nextArr(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextInt();
		return arr;
	}
	long[] nextArrL(int size) throws NumberFormatException, IOException {
		long[] arr = new long[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextLong();
		return arr;
	}
	double[] nextArrD(int size) throws NumberFormatException, IOException {
		double[] arr = new double[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextDouble();
		return arr;
	}
	String[] nextArrS(int size) throws NumberFormatException, IOException {
		String[] arr = new String[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextWord();
		return arr;
	}
	char[] nextArrCh(int size) throws IOException {
		char[] arr = new char[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrCh(int rows, int columns) throws IOException {
		char[][] arr = new char[rows][columns];
		for (int i=0; i<rows; ++i)
			for (int j=0; j<columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrChBorders(int rows, int columns, char border) throws IOException {
		char[][] arr = new char[rows+2][columns+2];
		for (int i=1; i<=rows; ++i)
			for (int j=1; j<=columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		for (int i=0; i<columns+2; ++i) {
			arr[0][i] = border;
			arr[rows+1][i] = border;
		}
		for (int i=0; i<rows+2; ++i) {
			arr[i][0] = border;
			arr[i][columns+1] = border;
		}
		return arr;
	}

	void printf(String format, Object... args) throws IOException {
		outputWriter.write(String.format(format, args));
	}
	void print(Object o) throws IOException {
		outputWriter.write(o.toString());
	}
	void println(Object o) throws IOException {
		outputWriter.write(o.toString());
		outputWriter.newLine();
	}
	void print(Object... o) throws IOException {
		for (int i=0; i<o.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(o[i].toString());
		}
	}
	void println(Object... o) throws IOException {
		print(o);
		outputWriter.newLine();
	}
	void printn(Object o, int n) throws IOException {
		String s = o.toString();
		for (int i=0; i<n; ++i) {
			outputWriter.write(s);
			if (i!=n-1) outputWriter.write(' ');
		}
	}
	void printnln(Object o, int n) throws IOException {
		printn(o, n);
		outputWriter.newLine();
	}
	void printArr(int[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Integer.toString(arr[i]));
		}
	}
	void printArr(long[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Long.toString(arr[i]));
		}
	}
	void printArr(double[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Double.toString(arr[i]));
		}
	}
	void printArr(String[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(arr[i]);
		}
	}
	void printlnArr(int[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(long[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(double[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(String[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void halt(Object... o) throws IOException {
		if (o.length!=0) println(o);
		outputWriter.flush(); outputWriter.close();
		System.exit(0);
	}

	void debug(Object... o) {
		if (showDebug) System.err.println(Arrays.deepToString(o));
	}

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.US);
		if (!useFiles) {
			inputReader = new InputReader(System.in, 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
		} else {
			inputReader = new InputReader(new FileInputStream(new File(inFile)), 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outFile))), 1<<16);
		}
		new D().solve();
		outputWriter.flush(); outputWriter.close();
	}
}


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

public class D {

	LinkedList<Integer>[] graph;
	int[] score;
	int toRootTot;
	boolean[] visited;
	int best = Integer.MAX_VALUE;

	public void solve() throws Exception {

		int n = nextInt();
		graph = new LinkedList[n];
		for (int i=0; i<n; ++i) graph[i] = new LinkedList<Integer>();
		for (int i=0; i<n-1; ++i) {
			int f = nextInt()-1, t = nextInt()-1;
			graph[f].addLast(t);
			graph[t].addLast(-f);
		}

		score = new int[n];
		visited = new boolean[n];
		dfs(0,0,0);

		println(best+toRootTot);
		for (int i=0; i<n; ++i) if (score[i]==best) print((i+1)+" ");

	}

	void dfs(int v, int fromCnt, int toCnt) {
		if (visited[v]) return;
		visited[v] = true;
		for (int s: graph[v]) if (!visited[abs(s)]) {
			if (s<0) {a
				score[-s] += fromCnt;
				score[-s] -= toCnt+1;
				toRootTot++;
				best = min(best, score[-s]);
				dfs(-s, fromCnt, toCnt+1);
			} else {
				score[s] += fromCnt+1;
				score[s] -= toCnt;
				best = min(best, score[s]);
				dfs(s, fromCnt+1, toCnt);
			}
		}
	}

	////////////////////////////////////////////////////////////////////////////

	boolean showDebug = true;
	static boolean useFiles = false;
	static String inFile = "input.txt";
	static String outFile = "output.txt";

	double EPS = 1e-7;
	int INF = Integer.MAX_VALUE;
	long INFL = Long.MAX_VALUE;
	double INFD = Double.MAX_VALUE;

	int absPos(int num) {
		return num<0 ? 0:num;
	}
	long absPos(long num) {
		return num<0 ? 0:num;
	}
	double absPos(double num) {
		return num<0 ? 0:num;
	}

	int min(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	int max(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	long minL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	long maxL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	double minD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	double maxD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}

	long sumArr(int[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	long sumArr(long[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	double sumArr(double[] arr) {
		double res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}

	long partsFitCnt(long partSize, long wholeSize) {
		return (partSize+wholeSize-1)/partSize;
	}

	boolean odd(long num) {
		return (num&1)==1;
	}

	boolean hasBit(int num, int pos) {
		return (num&(1<<pos))>0;
	}

	boolean isLetter(char c) {
		return (c>='a' && c<='z') || (c>='A' && c<='Z');
	}
	boolean isLowercase(char c) {
		return (c>='a' && c<='z');
	}
	boolean isUppercase(char c) {
		return (c>='A' && c<='Z');
	}
	boolean isDigit(char c) {
		return (c>='0' && c<='9');
	}

	boolean charIn(String chars, String s) {
		if (s==null) return false;
		if (chars==null || chars.equals("")) return true;
		for (int i=0; i<s.length(); ++i)
			for (int j=0; j<chars.length(); ++j)
				if (chars.charAt(j)==s.charAt(i)) return true;
		return false;
	}

	String stringn(String s, int n) {
		if (n<1 || s==null) return "";
		StringBuilder sb = new StringBuilder(s.length()*n);
		for (int i=0; i<n; ++i) sb.append(s);
		return sb.toString();
	}
	String str(Object o) {
		if (o==null) return "";
		return o.toString();
	}

	long timer = System.currentTimeMillis();
	void startTimer() {
		timer = System.currentTimeMillis();
	}
	void stopTimer() {
		System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
	}

	static class InputReader {
		private byte[] buf;
		private int bufPos = 0, bufLim = -1;
		private InputStream stream;
		public InputReader(InputStream stream, int size) {
			buf = new byte[size];
			this.stream = stream;
		}
		private void fillBuf() throws IOException {
			bufLim = stream.read(buf);
			bufPos = 0;
		}
		char read() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return (char)buf[bufPos++];
		}
		boolean hasInput() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return bufPos<bufLim;
		}
	}

	static InputReader inputReader;
	static BufferedWriter outputWriter;

	char nextChar() throws IOException {
		return inputReader.read();
	}
	char nextNonWhitespaceChar() throws IOException {
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		return c;
	}
	String nextWord() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c>' ') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	String nextLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c!='\n' && c!='\r') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	int nextInt() throws IOException {
		int r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r=c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10;
			r+=c-48;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	long nextLong() throws IOException {
		long r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r = c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10L;
			r+=c-48L;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextWord());
	}
	int[] nextArr(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextInt();
		return arr;
	}
	long[] nextArrL(int size) throws NumberFormatException, IOException {
		long[] arr = new long[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextLong();
		return arr;
	}
	double[] nextArrD(int size) throws NumberFormatException, IOException {
		double[] arr = new double[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextDouble();
		return arr;
	}
	String[] nextArrS(int size) throws NumberFormatException, IOException {
		String[] arr = new String[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextWord();
		return arr;
	}
	char[] nextArrCh(int size) throws IOException {
		char[] arr = new char[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrCh(int rows, int columns) throws IOException {
		char[][] arr = new char[rows][columns];
		for (int i=0; i<rows; ++i)
			for (int j=0; j<columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrChBorders(int rows, int columns, char border) throws IOException {
		char[][] arr = new char[rows+2][columns+2];
		for (int i=1; i<=rows; ++i)
			for (int j=1; j<=columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		for (int i=0; i<columns+2; ++i) {
			arr[0][i] = border;
			arr[rows+1][i] = border;
		}
		for (int i=0; i<rows+2; ++i) {
			arr[i][0] = border;
			arr[i][columns+1] = border;
		}
		return arr;
	}

	void printf(String format, Object... args) throws IOException {
		outputWriter.write(String.format(format, args));
	}
	void print(Object o) throws IOException {
		outputWriter.write(o.toString());
	}
	void println(Object o) throws IOException {
		outputWriter.write(o.toString());
		outputWriter.newLine();
	}
	void print(Object... o) throws IOException {
		for (int i=0; i<o.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(o[i].toString());
		}
	}
	void println(Object... o) throws IOException {
		print(o);
		outputWriter.newLine();
	}
	void printn(Object o, int n) throws IOException {
		String s = o.toString();
		for (int i=0; i<n; ++i) {
			outputWriter.write(s);
			if (i!=n-1) outputWriter.write(' ');
		}
	}
	void printnln(Object o, int n) throws IOException {
		printn(o, n);
		outputWriter.newLine();
	}
	void printArr(int[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Integer.toString(arr[i]));
		}
	}
	void printArr(long[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Long.toString(arr[i]));
		}
	}
	void printArr(double[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Double.toString(arr[i]));
		}
	}
	void printArr(String[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(arr[i]);
		}
	}
	void printlnArr(int[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(long[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(double[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(String[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void halt(Object... o) throws IOException {
		if (o.length!=0) println(o);
		outputWriter.flush(); outputWriter.close();
		System.exit(0);
	}

	void debug(Object... o) {
		if (showDebug) System.err.println(Arrays.deepToString(o));
	}

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.US);
		if (!useFiles) {
			inputReader = new InputReader(System.in, 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
		} else {
			inputReader = new InputReader(new FileInputStream(new File(inFile)), 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outFile))), 1<<16);
		}
		new D().solve();
		outputWriter.flush(); outputWriter.close();
	}
}


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

public class D {

	LinkedList<Integer>[] from, to;
	int[] fromRoot, toRoot;
	int toRootTot;
	boolean[] visited;

	public void solve() throws Exception {

		int n = nextInt();
		from = new LinkedList[n];
		to = new LinkedList[n];
		for (int i=0; i<n; ++i) {
			from[i] = new LinkedList<Integer>();
			to[i] = new LinkedList<Integer>();
		}
		for (int i=0; i<n-1; ++i) {
			int f = nextInt()-1, t = nextInt()-1;
			from[f].addLast(t);
			to[t].addLast(f);
		}

		fromRoot = new int[n];
		toRoot = new int[n];
		visited = new boolean[n];
		dfs(0,0,0);

		int[] score = new int[n];
		int best = INF;
		for (int i=0; i<n; ++i) {
			score[i] = toRootTot - toRoot[i] + fromRoot[i];
			best = min(best,score[i]);
		}
		println(best);
		for (int i=0; i<n; ++i) if (score[i]==best) print((i+1)+" ");

	}

	void dfs(int v, int fromCnt, int toCnt) {
		if (visited[v]) return;
		visited[v] = true;
		for (int s: from[v]) if (!visited[s]) {
			fromRoot[s] = fromCnt+1;
			toRoot[s] = toCnt;
			dfs(s, fromCnt+1, toCnt);
		}
		for (int s: to[v]) if (!visited[s]) {
			fromRoot[s] = fromCnt;
			toRoot[s] = toCnt+1;
			dfs(s, fromCnt, toCnt+1);
			toRootTot++;
		}
	}

	////////////////////////////////////////////////////////////////////////////

	boolean showDebug = true;
	static boolean useFiles = false;
	static String inFile = "input.txt";
	static String outFile = "output.txt";

	double EPS = 1e-7;
	int INF = Integer.MAX_VALUE;
	long INFL = Long.MAX_VALUE;
	double INFD = Double.MAX_VALUE;

	int absPos(int num) {
		return num<0 ? 0:num;
	}
	long absPos(long num) {
		return num<0 ? 0:num;
	}
	double absPos(double num) {
		return num<0 ? 0:num;
	}

	int min(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	int max(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	long minL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	long maxL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	double minD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	double maxD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}

	long sumArr(int[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	long sumArr(long[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	double sumArr(double[] arr) {
		double res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}

	long partsFitCnt(long partSize, long wholeSize) {
		return (partSize+wholeSize-1)/partSize;
	}

	boolean odd(long num) {
		return (num&1)==1;
	}

	boolean hasBit(int num, int pos) {
		return (num&(1<<pos))>0;
	}

	boolean isLetter(char c) {
		return (c>='a' && c<='z') || (c>='A' && c<='Z');
	}
	boolean isLowercase(char c) {
		return (c>='a' && c<='z');
	}
	boolean isUppercase(char c) {
		return (c>='A' && c<='Z');
	}
	boolean isDigit(char c) {
		return (c>='0' && c<='9');
	}

	boolean charIn(String chars, String s) {
		if (s==null) return false;
		if (chars==null || chars.equals("")) return true;
		for (int i=0; i<s.length(); ++i)
			for (int j=0; j<chars.length(); ++j)
				if (chars.charAt(j)==s.charAt(i)) return true;
		return false;
	}

	String stringn(String s, int n) {
		if (n<1 || s==null) return "";
		StringBuilder sb = new StringBuilder(s.length()*n);
		for (int i=0; i<n; ++i) sb.append(s);
		return sb.toString();
	}
	String str(Object o) {
		if (o==null) return "";
		return o.toString();
	}

	long timer = System.currentTimeMillis();
	void startTimer() {
		timer = System.currentTimeMillis();
	}
	void stopTimer() {
		System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
	}

	static class InputReader {
		private byte[] buf;
		private int bufPos = 0, bufLim = -1;
		private InputStream stream;
		public InputReader(InputStream stream, int size) {
			buf = new byte[size];
			this.stream = stream;
		}
		private void fillBuf() throws IOException {
			bufLim = stream.read(buf);
			bufPos = 0;
		}
		char read() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return (char)buf[bufPos++];
		}
		boolean hasInput() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return bufPos<bufLim;
		}
	}

	static InputReader inputReader;
	static BufferedWriter outputWriter;

	char nextChar() throws IOException {
		return inputReader.read();
	}
	char nextNonWhitespaceChar() throws IOException {
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		return c;
	}
	String nextWord() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c>' ') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	String nextLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c!='\n' && c!='\r') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	int nextInt() throws IOException {
		int r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r=c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10;
			r+=c-48;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	long nextLong() throws IOException {
		long r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r = c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10L;
			r+=c-48L;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextWord());
	}
	int[] nextArr(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextInt();
		return arr;
	}
	long[] nextArrL(int size) throws NumberFormatException, IOException {
		long[] arr = new long[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextLong();
		return arr;
	}
	double[] nextArrD(int size) throws NumberFormatException, IOException {
		double[] arr = new double[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextDouble();
		return arr;
	}
	String[] nextArrS(int size) throws NumberFormatException, IOException {
		String[] arr = new String[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextWord();
		return arr;
	}
	char[] nextArrCh(int size) throws IOException {
		char[] arr = new char[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrCh(int rows, int columns) throws IOException {
		char[][] arr = new char[rows][columns];
		for (int i=0; i<rows; ++i)
			for (int j=0; j<columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrChBorders(int rows, int columns, char border) throws IOException {
		char[][] arr = new char[rows+2][columns+2];
		for (int i=1; i<=rows; ++i)
			for (int j=1; j<=columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		for (int i=0; i<columns+2; ++i) {
			arr[0][i] = border;
			arr[rows+1][i] = border;
		}
		for (int i=0; i<rows+2; ++i) {
			arr[i][0] = border;
			arr[i][columns+1] = border;
		}
		return arr;
	}

	void printf(String format, Object... args) throws IOException {
		outputWriter.write(String.format(format, args));
	}
	void print(Object o) throws IOException {
		outputWriter.write(o.toString());
	}
	void println(Object o) throws IOException {
		outputWriter.write(o.toString());
		outputWriter.newLine();
	}
	void print(Object... o) throws IOException {
		for (int i=0; i<o.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(o[i].toString());
		}
	}
	void println(Object... o) throws IOException {
		print(o);
		outputWriter.newLine();
	}
	void printn(Object o, int n) throws IOException {
		String s = o.toString();
		for (int i=0; i<n; ++i) {
			outputWriter.write(s);
			if (i!=n-1) outputWriter.write(' ');
		}
	}
	void printnln(Object o, int n) throws IOException {
		printn(o, n);
		outputWriter.newLine();
	}
	void printArr(int[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Integer.toString(arr[i]));
		}
	}
	void printArr(long[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Long.toString(arr[i]));
		}
	}
	void printArr(double[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Double.toString(arr[i]));
		}
	}
	void printArr(String[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(arr[i]);
		}
	}
	void printlnArr(int[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(long[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(double[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(String[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void halt(Object... o) throws IOException {
		if (o.length!=0) println(o);
		outputWriter.flush(); outputWriter.close();
		System.exit(0);
	}

	void debug(Object... o) {
		if (showDebug) System.err.println(Arrays.deepToString(o));
	}

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.US);
		if (!useFiles) {
			inputReader = new InputReader(System.in, 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
		} else {
			inputReader = new InputReader(new FileInputStream(new File(inFile)), 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outFile))), 1<<16);
		}
		new D().solve();
		outputWriter.flush(); outputWriter.close();
	}
}


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

public class D {

	LinkedList<Integer>[] graph;
	int[] score;
	int toRootTot;
	boolean[] visited;
	int best = Integer.MAX_VALUE;

	public void solve() throws Exception {

		int n = nextInt();
		graph = new LinkedList[n];
		for (int i=0; i<n; ++i) graph[i] = new LinkedList<Integer>();
		for (int i=0; i<n-1; ++i) {
			int f = nextInt()-1, t = nextInt()-1;
			graph[f].addLast(t);
			graph[t].addLast(-f);
		}

		score = new int[n];
		visited = new boolean[n];
		dfs(0,0,0);

		println(best+toRootTot);
		for (int i=0; i<n; ++i) if (score[i]==best) print((i+1)+" ");

	}

	void dfs(int v, int fromCnt, int toCnt) {
		if (visited[v]) return;
		visited[v] = true;
		for (int s: graph[v]) if (!visited[abs(s)]) {
			if (s<0) {
				score[-s] += fromCnt;
				score[-s] -= toCnt+1;
				toRootTot++;
				best = min(best, score[-s]);
				dfs(-s, fromCnt, toCnt+1);
			} else {
				score[s] += fromCnt+1;
				score[s] -= toCnt;
				best = min(best, score[s]);
				dfs(s, fromCnt+1, toCnt);
			}
		}
	}

	////////////////////////////////////////////////////////////////////////////

	boolean showDebug = true;
	static boolean useFiles = false;
	static String inFile = "input.txt";
	static String outFile = "output.txt";

	double EPS = 1e-7;
	int INF = Integer.MAX_VALUE;
	long INFL = Long.MAX_VALUE;
	double INFD = Double.MAX_VALUE;

	int absPos(int num) {
		return num<0 ? 0:num;
	}
	long absPos(long num) {
		return num<0 ? 0:num;
	}
	double absPos(double num) {
		return num<0 ? 0:num;
	}

	int min(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	int max(int... nums) {
		int r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	long minL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	long maxL(long... nums) {
		long r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}
	double minD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]<r) r=nums[i];
		return r;
	}
	double maxD(double... nums) {
		double r = nums[0];
		for (int i=1; i<nums.length; ++i)
			if (nums[i]>r) r=nums[i];
		return r;
	}

	long sumArr(int[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	long sumArr(long[] arr) {
		long res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}
	double sumArr(double[] arr) {
		double res = 0;
		for (int i=0; i<arr.length; ++i)
			res+=arr[i];
		return res;
	}

	long partsFitCnt(long partSize, long wholeSize) {
		return (partSize+wholeSize-1)/partSize;
	}

	boolean odd(long num) {
		return (num&1)==1;
	}

	boolean hasBit(int num, int pos) {
		return (num&(1<<pos))>0;
	}

	boolean isLetter(char c) {
		return (c>='a' && c<='z') || (c>='A' && c<='Z');
	}
	boolean isLowercase(char c) {
		return (c>='a' && c<='z');
	}
	boolean isUppercase(char c) {
		return (c>='A' && c<='Z');
	}
	boolean isDigit(char c) {
		return (c>='0' && c<='9');
	}

	boolean charIn(String chars, String s) {
		if (s==null) return false;
		if (chars==null || chars.equals("")) return true;
		for (int i=0; i<s.length(); ++i)
			for (int j=0; j<chars.length(); ++j)
				if (chars.charAt(j)==s.charAt(i)) return true;
		return false;
	}

	String stringn(String s, int n) {
		if (n<1 || s==null) return "";
		StringBuilder sb = new StringBuilder(s.length()*n);
		for (int i=0; i<n; ++i) sb.append(s);
		return sb.toString();
	}
	String str(Object o) {
		if (o==null) return "";
		return o.toString();
	}

	long timer = System.currentTimeMillis();
	void startTimer() {
		timer = System.currentTimeMillis();
	}
	void stopTimer() {
		System.err.println("time: "+(System.currentTimeMillis()-timer)/1000.0);
	}

	static class InputReader {
		private byte[] buf;
		private int bufPos = 0, bufLim = -1;
		private InputStream stream;
		public InputReader(InputStream stream, int size) {
			buf = new byte[size];
			this.stream = stream;
		}
		private void fillBuf() throws IOException {
			bufLim = stream.read(buf);
			bufPos = 0;
		}
		char read() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return (char)buf[bufPos++];
		}
		boolean hasInput() throws IOException {
			if (bufPos>=bufLim) fillBuf();
			return bufPos<bufLim;
		}
	}

	static InputReader inputReader;
	static BufferedWriter outputWriter;

	char nextChar() throws IOException {
		return inputReader.read();
	}
	char nextNonWhitespaceChar() throws IOException {
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		return c;
	}
	String nextWord() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c>' ') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	String nextLine() throws IOException {
		StringBuilder sb = new StringBuilder();
		char c = inputReader.read();
		while (c<=' ') c=inputReader.read();
		while (c!='\n' && c!='\r') {
			sb.append(c);
			c = inputReader.read();
		}
		return new String(sb);
	}
	int nextInt() throws IOException {
		int r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r=c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10;
			r+=c-48;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	long nextLong() throws IOException {
		long r = 0;
		char c = nextNonWhitespaceChar();
		boolean neg = false;
		if (c=='-') neg=true;
		else r = c-48;
		c = nextChar();
		while (c>='0' && c<='9') {
			r*=10L;
			r+=c-48L;
			c=nextChar();
		}
		return neg ? -r:r;
	}
	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(nextWord());
	}
	int[] nextArr(int size) throws NumberFormatException, IOException {
		int[] arr = new int[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextInt();
		return arr;
	}
	long[] nextArrL(int size) throws NumberFormatException, IOException {
		long[] arr = new long[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextLong();
		return arr;
	}
	double[] nextArrD(int size) throws NumberFormatException, IOException {
		double[] arr = new double[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextDouble();
		return arr;
	}
	String[] nextArrS(int size) throws NumberFormatException, IOException {
		String[] arr = new String[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextWord();
		return arr;
	}
	char[] nextArrCh(int size) throws IOException {
		char[] arr = new char[size];
		for (int i=0; i<size; ++i)
			arr[i] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrCh(int rows, int columns) throws IOException {
		char[][] arr = new char[rows][columns];
		for (int i=0; i<rows; ++i)
			for (int j=0; j<columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		return arr;
	}
	char[][] nextArrChBorders(int rows, int columns, char border) throws IOException {
		char[][] arr = new char[rows+2][columns+2];
		for (int i=1; i<=rows; ++i)
			for (int j=1; j<=columns; ++j)
				arr[i][j] = nextNonWhitespaceChar();
		for (int i=0; i<columns+2; ++i) {
			arr[0][i] = border;
			arr[rows+1][i] = border;
		}
		for (int i=0; i<rows+2; ++i) {
			arr[i][0] = border;
			arr[i][columns+1] = border;
		}
		return arr;
	}

	void printf(String format, Object... args) throws IOException {
		outputWriter.write(String.format(format, args));
	}
	void print(Object o) throws IOException {
		outputWriter.write(o.toString());
	}
	void println(Object o) throws IOException {
		outputWriter.write(o.toString());
		outputWriter.newLine();
	}
	void print(Object... o) throws IOException {
		for (int i=0; i<o.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(o[i].toString());
		}
	}
	void println(Object... o) throws IOException {
		print(o);
		outputWriter.newLine();
	}
	void printn(Object o, int n) throws IOException {
		String s = o.toString();
		for (int i=0; i<n; ++i) {
			outputWriter.write(s);
			if (i!=n-1) outputWriter.write(' ');
		}
	}
	void printnln(Object o, int n) throws IOException {
		printn(o, n);
		outputWriter.newLine();
	}
	void printArr(int[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Integer.toString(arr[i]));
		}
	}
	void printArr(long[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Long.toString(arr[i]));
		}
	}
	void printArr(double[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(Double.toString(arr[i]));
		}
	}
	void printArr(String[] arr) throws IOException {
		for (int i=0; i<arr.length; ++i) {
			if (i!=0) outputWriter.write(' ');
			outputWriter.write(arr[i]);
		}
	}
	void printlnArr(int[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(long[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(double[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void printlnArr(String[] arr) throws IOException {
		printArr(arr);
		outputWriter.newLine();
	}
	void halt(Object... o) throws IOException {
		if (o.length!=0) println(o);
		outputWriter.flush(); outputWriter.close();
		System.exit(0);
	}

	void debug(Object... o) {
		if (showDebug) System.err.println(Arrays.deepToString(o));
	}

	public static void main(String[] args) throws Exception {
		Locale.setDefault(Locale.US);
		if (!useFiles) {
			inputReader = new InputReader(System.in, 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(System.out), 1<<16);
		} else {
			inputReader = new InputReader(new FileInputStream(new File(inFile)), 1<<16);
			outputWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(new File(outFile))), 1<<16);
		}
		new D().solve();
		outputWriter.flush(); outputWriter.close();
	}
}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
/**
 *
 * @author calcsaransh
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    static class Edge
    {
        int v,exist;
        public Edge(int V,int c)
        {

            v=V;
            exist=c;
        }
    }
    static LinkedList[] list;
    static int U[];
    static int D[];
    static int value[];

    static int totalU,totalD;
    public static void main(String[] args) {
        // TODO code application logic here
        try
        {

            Parserdoubt pd=new Parserdoubt(System.in);
            int n=pd.nextInt();
            U=new int[n+1];
            D=new int[n+1];
            value=new int[n+1];
            totalD=0;
            totalU=0;
            list=new LinkedList[n+1];
            for(int i=1;i<=n;i++)list[i]=new LinkedList();
            for(int i=0;i<n-1;i++)
            {
                int a=pd.nextInt();
                int b=pd.nextInt();
                list[a].add(new Edge(b,0));
                list[b].add(new Edge(a,1));
            }
            make(1,0,0,0);

            int minvalue = n+1;
            for(int i=1;i<=n;i++)
            {
                value[i] = totalU + D[i] - U[i];
                minvalue = Math.min(minvalue, value[i]);
            }

            System.out.println(minvalue);
            for(int i=1;i<=n;i++)
                if(value[i] == minvalue)
                    System.out.printf("%d ",i);
            System.out.println();

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    public static void make(int node,int from,int ups,int downs)
    {
        U[node]=ups;
        D[node]=downs;
        Iterator<Edge> iter=list[node].iterator();
        while(iter.hasNext())
        {
            Edge tmp=iter.next();
            if(tmp.v!=from)
            {
                int u=ups;
                int d=downs;
                if(tmp.exist == 0)
                {
                    totalD++;
                    d++;
                }
                else
                {
                    totalU++;
                    u++;
                }

                make(tmp.v,node,u,d);
            }
        }
    }

}

class Parserdoubt {

    final private int BUFFER_SIZE = 1 << 17;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Parserdoubt(InputStream in) {
        din = new DataInputStream(in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String nextString() throws Exception {
        StringBuffer sb = new StringBuffer("");
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        do {
            sb.append((char) c);
            c = read();
        } while (c > ' ');
        return sb.toString();
    }

    public char nextChar() throws Exception {
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        return (char) c;
    }

    public int nextInt() throws Exception {
        int ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    public long nextLong() throws Exception {
        long ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    private void fillBuffer() throws Exception {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1) {
            buffer[0] = -1;
        }
    }

    private byte read() throws Exception {
        if (bufferPointer == bytesRead) {
            fillBuffer();
        }
        return buffer[bufferPointer++];
    }
}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.*;
/**
 *
 * @author calcsaransh
 */
public class Main {

    /**
     * @param args the command line arguments
     */
    static class Edge
    {
        int v,exist;
        public Edge(int V,int c)
        {

            v=V;
            exist=c;
        }
    }
    static LinkedList[] list;
    static int U[];
    static int D[];
    static int value[];

    static int totalU,totalD;
    public static void main(String[] args) {
        // TODO code application logic here
        try
        {

            Parserdoubt pd=new Parserdoubt(System.in);
            int n=pd.nextInt();
            U=new int[n+1];
            D=new int[n+1];
            value=new int[n+1];
            totalD=0;
            totalU=0;
            list=new LinkedList[n+1];
            for(int i=1;i<=n;i++)list[i]=new LinkedList();
            for(int i=0;i<n-1;i++)
            {
                int a=pd.nextInt();
                int b=pd.nextInt();
                list[a].add(new Edge(b,0));
                list[b].add(new Edge(a,1));
            }
            make(1,0,0,0);

            int minvalue = n+1;
            for(int i=1;i<=n;i++)
            {
                value[i] = totalU + D[i] - U[i];
                minvalue = Math.min(minvalue, value[i]);
            }
            PrintWriter pw=new PrintWriter(System.out);
            pw.println(minvalue);
            for(int i=1;i<=n;i++)
                if(value[i] == minvalue)
                    pw.printf("%d ",i);
            pw.println();
            pw.flush();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    public static void make(int node,int from,int ups,int downs)
    {
        U[node]=ups;
        D[node]=downs;
        Iterator<Edge> iter=list[node].iterator();
        while(iter.hasNext())
        {
            Edge tmp=iter.next();
            if(tmp.v!=from)
            {
                int u=ups;
                int d=downs;
                if(tmp.exist == 0)
                {
                    totalD++;
                    d++;
                }
                else
                {
                    totalU++;
                    u++;
                }

                make(tmp.v,node,u,d);
            }
        }
    }

}

class Parserdoubt {

    final private int BUFFER_SIZE = 1 << 17;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Parserdoubt(InputStream in) {
        din = new DataInputStream(in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String nextString() throws Exception {
        StringBuffer sb = new StringBuffer("");
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        do {
            sb.append((char) c);
            c = read();
        } while (c > ' ');
        return sb.toString();
    }

    public char nextChar() throws Exception {
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        return (char) c;
    }

    public int nextInt() throws Exception {
        int ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    public long nextLong() throws Exception {
        long ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    private void fillBuffer() throws Exception {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1) {
            buffer[0] = -1;
        }
    }

    private byte read() throws Exception {
        if (bufferPointer == bytesRead) {
            fillBuffer();
        }
        return buffer[bufferPointer++];
    }
}