// https://resources.beecrowd.com/repository/UOJ_2354_es.html 
#include <deque> 
#include <climits> 
#include <iostream> 
#include <utility> 
#include <vector> 
 
struct grafica_flujo { 
   std::vector<std::vector<int>> listas; 
   std::vector<std::vector<int>> capacidad; 
   int fuente, sumidero; 
 
   grafica_flujo(int n, int f, int s) 
   : listas(n), capacidad(n, std::vector<int>(n, 0)), fuente(f), sumidero(s) { 
   } 
 
   void agrega_arco(int v1, int v2, int c) { 
      listas[v1].push_back(v2); 
      listas[v2].push_back(v1); 
      capacidad[v1][v2] = c; 
   } 
 
   int flujo_maximo( ) { 
      int res = 0; 
      for (;;) { 
         auto [flujo, camino] = aumenta_flujo( ); 
         if (flujo == 0) { 
            return res; 
         } 
         res += flujo; 
         for (auto [v1, v2] : camino) { 
            capacidad[v1][v2] -= flujo; 
            capacidad[v2][v1] += flujo; 
         } 
      } 
   } 
 
   std::pair<int, std::vector<std::pair<int, int>>> aumenta_flujo( ) { 
      std::deque<int> cola = { fuente }; 
      std::vector<int> distancia(listas.size( ), -1), previo(listas.size( ), -1); 
      distancia[fuente] = 0; 
      previo[fuente] = fuente; 
      do { 
         int procesar = cola.front( ); 
         cola.pop_front( ); 
         for (int v : listas[procesar]) { 
            if (distancia[v] == -1 && capacidad[procesar][v] > 0) { 
               distancia[v] = distancia[procesar] + 1; 
               previo[v] = procesar; 
               cola.push_back(v); 
            } 
         } 
      } while (!cola.empty( )); 
 
      if (distancia[sumidero] == -1) { 
         return { 0, { } }; 
      } else { 
         std::vector<std::pair<int, int>> camino; 
         int flujo = INT_MAX, actual = sumidero; 
         do { 
            int anterior = previo[actual]; 
            camino.push_back({ anterior, actual }); 
            flujo = std::min(flujo, capacidad[anterior][actual]); 
            actual = anterior; 
         } while (actual != fuente); 
         return { flujo, camino }; 
      } 
   } 
}; 
 
int main( ) { 
   int n; 
   std::cin >> n; 
 
   int candidatos[n][2]; 
   for (int i = 0; i < n; ++i) { 
      std::cin >> candidatos[i][0] >> candidatos[i][1]; 
      candidatos[i][0] -= 1; 
      candidatos[i][1] -= 1; 
   } 
 
   int lobo_victorias = 0; 
   for (int w = 0; w < n; ++w) { 
      int lobo_recibidos = 0; 
      for (int i = 0; i < n; ++i) { 
         lobo_recibidos += (candidatos[i][0] == w); 
         lobo_recibidos += (candidatos[i][1] == w); 
      } 
 
      int vertices = 2 * n + 2; 
      int fuente = 2 * n; 
      int sumidero = 2 * n + 1; 
      grafica_flujo g(vertices, fuente, sumidero); 
 
      // de la fuente al primer piso 
      for (int i = 0; i < n; ++i) { 
         if (i != w && candidatos[i][0] != w && candidatos[i][1] != w) { 
            g.agrega_arco(fuente, i, 1); 
         } 
      } 
 
      // del primer piso al segundo piso 
      for (int i = 0; i < n; ++i) { 
         g.agrega_arco(i, candidatos[i][0] + n, 1); 
         g.agrega_arco(i, candidatos[i][1] + n, 1); 
      } 
 
      // del segundo piso al sumidero 
      for (int i = 0; i < n; ++i) { 
         if (i != w) { 
            int votos_tolerados = lobo_recibidos - 1; 
            if (candidatos[w][0] == i || candidatos[w][1] == i) { 
               votos_tolerados -= 1; 
            } 
            g.agrega_arco(i + n, sumidero, votos_tolerados); 
         } 
      } 
      lobo_victorias += (g.flujo_maximo( ) < n - 1 - lobo_recibidos); 
   } 
 
   std::cout << lobo_victorias; 
}