#!/usr/bin/env python3

from collections import defaultdict,deque

from heapq import heappush, heappop

from bisect import bisect_left, bisect_right

import sys, random, itertools, math

sys.setrecursionlimit(10**5)

input = sys.stdin.readline

sqrt = math.sqrt

def LI(): return list(map(int, input().split()))

def LF(): return list(map(float, input().split()))

def LI_(): return list([int(x)-1 for x in input().split()])

def II(): return int(eval(input()))

def IF(): return float(eval(input()))

def S(): return input().rstrip()

def LS(): return S().split()

def IR(n): return [II() for _ in range(n)]

def LIR(n): return [LI() for _ in range(n)]

def FR(n): return [IF() for _ in range(n)]

def LFR(n): return [LI() for _ in range(n)]

def LIR_(n): return [LI_() for _ in range(n)]

def SR(n): return [S() for _ in range(n)]

def LSR(n): return [LS() for _ in range(n)]

mod = 1000000007

inf = float("INF")



#solve

def solve():

    n, k = LI()

    ans = [1] * n

    for _ in range(k):

        d = II()

        a = LI_()

        for ai in a:

            ans[ai] = 0

    print((sum(ans)))

    return





#main

if __name__ == '__main__':

    solve()

#!usr/bin/env python3

from collections import defaultdict, deque

from heapq import heappush, heappop

from itertools import permutations, accumulate

import sys

import math

import bisect

def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]

def I(): return int(sys.stdin.buffer.readline())

def LS():return [list(x) for x in sys.stdin.readline().split()]

def S():

    res = list(sys.stdin.readline())

    if res[-1] == "\n":

        return res[:-1]

    return res

def IR(n):

    return [I() for i in range(n)]

def LIR(n):

    return [LI() for i in range(n)]

def SR(n):

    return [S() for i in range(n)]

def LSR(n):

    return [LS() for i in range(n)]



sys.setrecursionlimit(1000000)

mod = 1000000007



def solve():

    n,k = LI()

    d = [0]*n

    for _ in range(k):

        LI()

        a = LI()

        for i in a:

            d[i-1] = 1

    print((n-sum(d)))

    return



#Solve

if __name__ == "__main__":

    solve()

#!/usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math

sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


def LI():
    return list(map(int, input().split()))


def LF():
    return list(map(float, input().split()))


def LI_():
    return list([int(x) - 1 for x in input().split()])


def II():
    return int(eval(input()))


def IF():
    return float(eval(input()))


def S():
    return input().rstrip()


def LS():
    return S().split()


def IR(n):
    return [II() for _ in range(n)]


def LIR(n):
    return [LI() for _ in range(n)]


def FR(n):
    return [IF() for _ in range(n)]


def LFR(n):
    return [LI() for _ in range(n)]


def LIR_(n):
    return [LI_() for _ in range(n)]


def SR(n):
    return [S() for _ in range(n)]


def LSR(n):
    return [LS() for _ in range(n)]


mod = 1000000007
inf = float("INF")
# solve
def solve():
    n, k = LI()
    ans = [1] * n
    for _ in range(k):
        d = II()
        a = LI_()
        for ai in a:
            ans[ai] = 0
    print((sum(ans)))
    return


# main
if __name__ == "__main__":
    solve()

#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect


def LI():
    return [int(x) for x in sys.stdin.buffer.readline().split()]


def I():
    return int(sys.stdin.buffer.readline())


def LS():
    return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


def IR(n):
    return [I() for i in range(n)]


def LIR(n):
    return [LI() for i in range(n)]


def SR(n):
    return [S() for i in range(n)]


def LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
    n, k = LI()
    d = [0] * n
    for _ in range(k):
        LI()
        a = LI()
        for i in a:
            d[i - 1] = 1
    print((n - sum(d)))
    return


# Solve
if __name__ == "__main__":
    solve()

-#!/usr/bin/env python3 +#!usr/bin/env python3 -from bisect import bisect_left, bisect_right -import sys, random, itertools, math - -sys.setrecursionlimit(10**5) -input = sys.stdin.readline -sqrt = math.sqrt +from itertools import permutations, accumulate +import sys +import math +import bisect -    return list(map(int, input().split())) +    return [int(x) for x in sys.stdin.buffer.readline().split()] -def LF(): -    return list(map(float, input().split())) +def I(): +    return int(sys.stdin.buffer.readline()) -def LI_(): -    return list([int(x) - 1 for x in input().split()]) - - -def II(): -    return int(eval(input())) - - -def IF(): -    return float(eval(input())) +def LS(): +    return [list(x) for x in sys.stdin.readline().split()] -    return input().rstrip() - - -def LS(): -    return S().split() +    res = list(sys.stdin.readline()) +    if res[-1] == "\n": +        return res[:-1] +    return res -    return [II() for _ in range(n)] +    return [I() for i in range(n)] -    return [LI() for _ in range(n)] - - -def FR(n): -    return [IF() for _ in range(n)] - - -def LFR(n): -    return [LI() for _ in range(n)] - - -def LIR_(n): -    return [LI_() for _ in range(n)] +    return [LI() for i in range(n)] -    return [S() for _ in range(n)] +    return [S() for i in range(n)] -    return [LS() for _ in range(n)] +    return [LS() for i in range(n)] +sys.setrecursionlimit(1000000) -inf = float("INF") -# solve + + -    ans = [1] * n +    d = [0] * n -        d = II() -        a = LI_() -        for ai in a: -            ans[ai] = 0 -    print((sum(ans))) +        LI() +        a = LI() +        for i in a: +            d[i - 1] = 1 +    print((n - sum(d))) -# main +# Solve