Problem:
Score : 200 points

Problem Statement

N Snukes called Snuke 1, Snuke 2, ..., Snuke N live in a town.

There are K kinds of snacks sold in this town, called Snack 1, Snack 2, ..., Snack K. The following d_i Snukes have Snack i: Snuke A_{i, 1}, A_{i, 2}, \cdots, A_{i, {d_i}}.

Takahashi will walk around this town and make mischief on the Snukes who have no snacks. How many Snukes will fall victim to Takahashi's mischief?

Constraints

All values in input are integers.

1 \leq N \leq 100

1 \leq K \leq 100

1 \leq d_i \leq N

1 \leq A_{i, 1} < \cdots < A_{i, d_i} \leq N

Input

Input is given from Standard Input in the following format:

N K
d_1
A_{1, 1} \cdots A_{1, d_1}
\vdots
d_K
A_{K, 1} \cdots A_{K, d_K}

Output

Print the answer.

Sample Input 1

3 2
2
1 3
1
3

Sample Output 1

1

Snuke 1 has Snack 1.

Snuke 2 has no snacks.

Snuke 3 has Snack 1 and 2.

Thus, there will be one victim: Snuke 2.

Sample Input 2

3 3
1
3
1
3
1
3

Sample Output 2

2

Solution in Rust (1.42.0) (judge verdict: Accepted)

// The main code is at the very bottom.

#[allow(unused_imports)]
use {
    lib::byte::ByteChar,
    std::cell::{Cell, RefCell},
    std::cmp::{
        self,
        Ordering::{self, *},
        Reverse,
    },
    std::collections::*,
    std::convert::identity,
    std::fmt::{self, Debug, Display, Formatter},
    std::io::prelude::*,
    std::iter::{self, FromIterator},
    std::marker::PhantomData,
    std::mem,
    std::num::Wrapping,
    std::ops::{Range, RangeFrom, RangeInclusive, RangeTo, RangeToInclusive},
    std::process,
    std::rc::Rc,
    std::thread,
    std::time::{Duration, Instant},
    std::{char, f32, f64, i128, i16, i32, i64, i8, isize, str, u128, u16, u32, u64, u8, usize},
};

#[allow(unused_imports)]
#[macro_use]
pub mod lib {
    pub mod byte {
        pub use self::byte_char::*;

        mod byte_char {
            use std::error::Error;
            use std::fmt::{self, Debug, Display, Formatter};
            use std::str::FromStr;

            #[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
            #[repr(transparent)]
            pub struct ByteChar(pub u8);

            impl Debug for ByteChar {
                fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                    write!(f, "b'{}'", self.0 as char)
                }
            }

            impl Display for ByteChar {
                fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                    write!(f, "{}", self.0 as char)
                }
            }

            impl FromStr for ByteChar {
                type Err = ParseByteCharError;

                fn from_str(s: &str) -> Result<ByteChar, ParseByteCharError> {
                    match s.as_bytes().len() {
                        1 => Ok(ByteChar(s.as_bytes()[0])),
                        0 => Err(ParseByteCharErrorKind::EmptyStr.into()),
                        _ => Err(ParseByteCharErrorKind::TooManyBytes.into()),
                    }
                }
            }

            #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
            pub struct ParseByteCharError {
                kind: ParseByteCharErrorKind,
            }

            impl Display for ParseByteCharError {
                fn fmt(&self, f: &mut Formatter) -> fmt::Result {
                    f.write_str(match self.kind {
                        ParseByteCharErrorKind::EmptyStr => "empty string",
                        ParseByteCharErrorKind::TooManyBytes => "too many bytes",
                    })
                }
            }

            impl Error for ParseByteCharError {}

            #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
            enum ParseByteCharErrorKind {
                EmptyStr,
                TooManyBytes,
            }

            impl From<ParseByteCharErrorKind> for ParseByteCharError {
                fn from(kind: ParseByteCharErrorKind) -> ParseByteCharError {
                    ParseByteCharError { kind }
                }
            }
        }
    }

    pub mod io {
        pub use self::scanner::*;

        mod scanner {
            use std::io::{self, BufRead};
            use std::iter;
            use std::str::FromStr;

            #[derive(Debug)]
            pub struct Scanner<R> {
                reader: R,
                buf: String,
                pos: usize,
            }

            impl<R: BufRead> Scanner<R> {
                pub fn new(reader: R) -> Self {
                    Scanner {
                        reader,
                        buf: String::new(),
                        pos: 0,
                    }
                }

                pub fn next(&mut self) -> io::Result<&str> {
                    let start = loop {
                        match self.rest().find(|c| c != ' ') {
                            Some(i) => break i,
                            None => self.fill_buf()?,
                        }
                    };
                    self.pos += start;
                    let len = self.rest().find(' ').unwrap_or(self.rest().len());
                    let s = &self.buf[self.pos..][..len]; // self.rest()[..len]
                    self.pos += len;
                    Ok(s)
                }

                pub fn parse_next<T>(&mut self) -> io::Result<Result<T, T::Err>>
                    where
                        T: FromStr,
                {
                    Ok(self.next()?.parse())
                }

                pub fn parse_next_n<T>(&mut self, n: usize) -> io::Result<Result<Vec<T>, T::Err>>
                    where
                        T: FromStr,
                {
                    iter::repeat_with(|| self.parse_next()).take(n).collect()
                }

                pub fn map_next_bytes<T, F>(&mut self, mut f: F) -> io::Result<Vec<T>>
                    where
                        F: FnMut(u8) -> T,
                {
                    Ok(self.next()?.bytes().map(&mut f).collect())
                }

                pub fn map_next_bytes_n<T, F>(&mut self, n: usize, mut f: F) -> io::Result<Vec<Vec<T>>>
                    where
                        F: FnMut(u8) -> T,
                {
                    iter::repeat_with(|| self.map_next_bytes(&mut f))
                        .take(n)
                        .collect()
                }

                fn rest(&self) -> &str {
                    &self.buf[self.pos..]
                }

                fn fill_buf(&mut self) -> io::Result<()> {
                    self.buf.clear();
                    self.pos = 0;
                    let read = self.reader.read_line(&mut self.buf)?;
                    if read == 0 {
                        return Err(io::ErrorKind::UnexpectedEof.into());
                    }
                    if *self.buf.as_bytes().last().unwrap() == b'\n' {
                        self.buf.pop();
                    }
                    Ok(())
                }
            }
        }
    }
}

#[allow(unused_macros)]
macro_rules! eprint {
  ($($arg:tt)*) => {
    if cfg!(debug_assertions) {
      std::eprint!($($arg)*)
    }
  };
}
#[allow(unused_macros)]
macro_rules! eprintln {
  ($($arg:tt)*) => {
    if cfg!(debug_assertions) {
      std::eprintln!($($arg)*)
    }
  };
}
#[allow(unused_macros)]
macro_rules! dbg {
  ($($arg:tt)*) => {
    if cfg!(debug_assertions) {
      std::dbg!($($arg)*)
    } else {
      ($($arg)*)
    }
  };
}

const CUSTOM_STACK_SIZE_MIB: Option<usize> = Some(128);
const INTERACTIVE: bool = false;

fn main() -> std::io::Result<()> {
    match CUSTOM_STACK_SIZE_MIB {
        Some(stack_size_mib) => std::thread::Builder::new()
            .name("run_solver".to_owned())
            .stack_size(stack_size_mib * 1024 * 1024)
            .spawn(run_solver)?
            .join()
            .unwrap(),
        None => run_solver(),
    }
}

fn run_solver() -> std::io::Result<()> {
    let stdin = std::io::stdin();
    let reader = stdin.lock();
    let stdout = std::io::stdout();
    let writer = stdout.lock();
    macro_rules! with_wrapper {
    ($($wrapper:expr)?) => {{
      let mut writer = $($wrapper)?(writer);
      solve(reader, &mut writer)?;
      writer.flush()
    }};
  }
    if cfg!(debug_assertions) {
        with_wrapper!()
    } else if INTERACTIVE {
        with_wrapper!(std::io::LineWriter::new)
    } else {
        with_wrapper!(std::io::BufWriter::new)
    }
}

fn solve<R, W>(reader: R, mut writer: W) -> std::io::Result<()>
    where
        R: BufRead,
        W: Write,
{
    let mut _scanner = lib::io::Scanner::new(reader);
    #[allow(unused_macros)]
    macro_rules! scan {
    ($T:ty) => {
      _scanner.parse_next::<$T>()?.unwrap()
    };
    ($($T:ty),+) => {
      ($(scan!($T)),+)
    };
    ($T:ty; $n:expr) => {
      _scanner.parse_next_n::<$T>($n)?.unwrap()
    };
    ($($T:ty),+; $n:expr) => {
      iter::repeat_with(|| -> std::io::Result<_> { Ok(($(scan!($T)),+)) })
        .take($n)
        .collect::<std::io::Result<Vec<_>>>()?
    };
  }
    #[allow(unused_macros)]
    macro_rules! scan_bytes_map {
    ($f:expr) => {
      _scanner.map_next_bytes($f)?
    };
    ($f:expr; $n:expr) => {
      _scanner.map_next_bytes_n($n, $f)?
    };
  }
    #[allow(unused_macros)]
    macro_rules! print {
    ($($arg:tt)*) => {
      write!(writer, $($arg)*)?
    };
  }
    #[allow(unused_macros)]
    macro_rules! println {
    ($($arg:tt)*) => {
      writeln!(writer, $($arg)*)?
    };
  }
    {
        let (n, k) = scan!(usize, usize);

        let mut set = HashSet::new();

        for _ in 0..k {
            let d = scan!(usize);
            for _i in 0..d {
                let add = scan!(usize);
                set.insert(add);
            }
        }

        let ans = n - set.len();
        
        println!("{}", ans);
    }
    Ok(())
}