import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  }
} import java.util.Scanner; Scanner java.util public class Main {
  public static void main(String[] args) {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  }
} Main public static void main(String[] args) {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  } main {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  } Scanner stdIn = new Scanner(System.in); stdIn new Scanner(System.in) try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    } catch (Exception e) {
      e.printStackTrace();
    } Exception e {
      e.printStackTrace();
    } e.printStackTrace() e.printStackTrace e {
      stdIn.close();
    } stdIn.close() stdIn.close stdIn {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } int childrenNum = stdIn.nextInt(); childrenNum stdIn.nextInt() stdIn.nextInt stdIn if (childrenNum < 1 || childrenNum > 100) return; childrenNum < 1 || childrenNum > 100 childrenNum < 1 childrenNum 1 childrenNum > 100 childrenNum 100 return; int[][] childrenSnack = new int[childrenNum + 1][2]; childrenSnack new int[childrenNum + 1][2] childrenNum + 1 childrenNum 1 2 int snackNum = stdIn.nextInt(); snackNum stdIn.nextInt() stdIn.nextInt stdIn if (snackNum < 1 || snackNum > 100) return; snackNum < 1 || snackNum > 100 snackNum < 1 snackNum 1 snackNum > 100 snackNum 100 return; for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      } int snackCnt = 0; int snackCnt = 0; snackCnt 0 snackCnt < snackNum snackCnt snackNum snackCnt++ snackCnt++ snackCnt {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      } {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      } int havingSnackNum = stdIn.nextInt(); havingSnackNum stdIn.nextInt() stdIn.nextInt stdIn if (havingSnackNum < 1 || havingSnackNum > childrenNum) return; havingSnackNum < 1 || havingSnackNum > childrenNum havingSnackNum < 1 havingSnackNum 1 havingSnackNum > childrenNum havingSnackNum childrenNum return; for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        } int cnt = 0; int cnt = 0; cnt 0 cnt < havingSnackNum cnt havingSnackNum cnt++ cnt++ cnt {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        } {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        } int temphavingChild = stdIn.nextInt(); temphavingChild stdIn.nextInt() stdIn.nextInt stdIn childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1 childrenSnack[temphavingChild][0] childrenSnack[temphavingChild] childrenSnack temphavingChild 0 childrenSnack[temphavingChild][0] + 1 childrenSnack[temphavingChild][0] childrenSnack[temphavingChild] childrenSnack temphavingChild 0 1 int notHavingNum = 0; notHavingNum 0 for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      } int searchCnt = 1; int searchCnt = 1; searchCnt 1 searchCnt <= childrenNum searchCnt childrenNum searchCnt++ searchCnt++ searchCnt {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      } {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      } if (childrenSnack[searchCnt][0] == 0) notHavingNum++; childrenSnack[searchCnt][0] == 0 childrenSnack[searchCnt][0] childrenSnack[searchCnt] childrenSnack searchCnt 0 0 notHavingNum++ notHavingNum System.out.println(notHavingNum) System.out.println System.out System System.out notHavingNum String[] args args public class Main {
  public static void main(String[] args) {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  }
} public class Main {
  public static void main(String[] args) {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  }
} Main
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner stdIn = new Scanner(System.in);
    try {
      int childrenNum = stdIn.nextInt();
      if (childrenNum < 1 || childrenNum > 100) return;
      int[][] childrenSnack = new int[childrenNum + 1][2];
      int snackNum = stdIn.nextInt();
      if (snackNum < 1 || snackNum > 100) return;
      for (int snackCnt = 0; snackCnt < snackNum; snackCnt++) {
        int havingSnackNum = stdIn.nextInt();
        if (havingSnackNum < 1 || havingSnackNum > childrenNum) return;
        for (int cnt = 0; cnt < havingSnackNum; cnt++) {
          int temphavingChild = stdIn.nextInt();
          childrenSnack[temphavingChild][0] = childrenSnack[temphavingChild][0] + 1;
        }
      }
      int notHavingNum = 0;
      for (int searchCnt = 1; searchCnt <= childrenNum; searchCnt++) {
        if (childrenSnack[searchCnt][0] == 0) notHavingNum++;
      }
      System.out.println(notHavingNum);
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      stdIn.close();
    }
  }
}