import java.io.PrintWriter
import java.util.*
import kotlin.collections.HashSet
import kotlin.math.max

@JvmField
    val INPUT = System.`in`!!
    @JvmField
    val OUTPUT = System.out!!

    @JvmField
    val reader = INPUT.bufferedReader()

    fun readLine(): String? = reader.readLine()
    fun readLn() = reader.readLine()!!
    @JvmField
    var tokenizer: StringTokenizer = StringTokenizer("")

    fun read(): String {
        while (tokenizer.hasMoreTokens().not()) tokenizer = StringTokenizer(reader.readLine() ?: return "", " ")
        return tokenizer.nextToken()
    }

    fun readInt() = read().toInt()
    fun readDouble() = read().toDouble()
    fun readLong() = read().toLong()
    fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
    fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
    fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

    @JvmField
    val rw = PrintWriter(OUTPUT, false)

    inline fun output(block: PrintWriter.() -> Unit) {
        rw.apply(block).flush()
    }

    fun printLArray(a: LongArray) { a.forEach { x -> rw.print(x); rw.print(" ") };rw.println() }
    fun printIArray(a: IntArray) { a.forEach { x -> rw.print(x);rw.print(" ") };rw.println() }

    private var is_prime: BooleanArray? = null
    private var prime: ArrayList<Int>? = null
    fun sieve(n: Int) {
        is_prime = BooleanArray(n + 10)
        prime = ArrayList()
        for (i in 2..n) is_prime!![i] = true
        for (i in 2..n) {
            if (is_prime!![i]) prime!!.add(i)
            var j = 0
            while (j < prime!!.size && i * prime!![j] < n) {
                is_prime!![i * prime!![j]] = false
                if (i % prime!![j] == 0) break
                ++j
            }
        }
    }

    fun mergeSort(a: IntArray) {
        val n = a.size
        if (n < 2) return
        val mid = n / 2; val left = IntArray(mid); val right = IntArray(n - mid)
        for (i in 0 until mid) left[i] = a[i]
        for (i in mid until n) right[i - mid] = a[i]
        mergeSort(left);mergeSort(right);merge(left, right, a)
    }

    fun merge(left: IntArray, right: IntArray, a: IntArray) {
        val nLeft = left.size; val nRight = right.size
        var i = 0; var j = 0; var k = 0
        while (i < nLeft && j < nRight) {
            if (left[i] <= right[j]) {
                a[k] = left[i];k++;i++
            } else {
                a[k] = right[j]; k++;j++
            }
        }
        while (i < nLeft) {a[k] = left[i]; i++; k++}
        while (j < nRight){a[k] = right[j]; j++; k++}
    }

    fun gcd(a: Long, b: Long): Long {
        if (b == 0L) return a
        return gcd(b, a % b)
    }

    fun smallest(a: IntArray): Int {
        var min = a[0]
        for (i in 1 until a.size) {
            if (a[i] < min) min = a[i]
        }
        return min
    }
fun main(){

    val n = readInt()
    var k = readInt()
    val set = HashSet<Int>()
    while (k-- > 0){
       var d = readInt()
        while (d-- > 0){
            val e = readInt()
            set.add(e)
        }
    }
    rw.println(n-set.size)

    rw.close()
}