import java.util.Scanner;
/*
 * 
S 120.
Horcsin Bálint 9. évf.
Budapest, Németh László Gimnázium

Fordtó program: Java 8, Fejlesztői környezet: NetBeans 8.2
 */



public class s120 {
/*
12 10
3 2 3 6 7
6 1
2 1 4
5 3
4 6
4 5 1 9 10 11
4 1 8
6 7 12
6 6 
5 6
2 6
3 8 
 
 
 */
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);	//Beolvasó létrehozása
		int M = sc.nextInt();	//M beolvasása
		int U = sc.nextInt();	//U beolvasása (nem használt)
		sc.nextLine();		//Újraolvasás elkerülése
		Pont[] p= new Pont[M];	//Pont objektumok tömbjének létrehozása
		
		for(int i=0;i<M;i++) {
			//Összes Pont objektum beolvasása
			String st = sc.nextLine();
			String[] a = st.split(" ");
			int[] kap=new int[a.length-1];
			for(int j=1;j<a.length;j++) {
				kap[j-1]=Integer.parseInt(a[j])-1;
			}
			p[i] = new Pont(Integer.parseInt(a[0]), kap);
		}
		
		Pont.pontok=p;	//Pontok elhelyezése osztályváltozóként
		
		
		while(Pont.updateAll()) {}	//Útvonalkeresés
		
		
		Pont.pontok[0].InduloUpdate();	//Kiindulóállomás kiszámolása
		
		System.out.println(Pont.pontok[0].eddig);	//Kiindulóállomás kiírása
		//FOR DEBUG:
		/*for(int i=0;i<M;i++) {
			System.out.println((i+1)+" "+Pont.pontok[i].eddig);
		}*/
	}
	
	
	public static class Pont {
		
		int[] kapcs;	//A megálló többi megállóval lévő kapcsolatai (azok sorszámával).
		private int hany;	//A megállóban eredetileg álló utasok száma. Másik objektumnak, static-us algoritmusnak nem kell hozzáférnie, maga az objektum kiszámolja a szükséges adatokat.
		static Pont[] pontok;	//Az osztály összes objektumát tartalmazó tömb.
		
		static boolean tortent=false;	//Az updateAll() ellenőrző változója.
		
		boolean mar=false;	//Már ki van számítva?
		int eddig=0;	//Ha csak a tőle kívüleső pontokat(1)  és őt vesszük, akkor a megtehető utak maximális száma.
						//(1) Ezek azok a pontok, amelyekre való eljutáshoz nem kell használni a viszonyítási ponttól az 1. ponthoz szükséges legrövidebb út szakaszait.
		int publichany=0;	//A fenti utak megtétele után a megállóban lévő utasok száma.
		
		
		public Pont(int hanyan, int[] kapcsolat) {
			hany = hanyan;
			kapcs = kapcsolat;
		}
		
		public void update() {
				//Gondolatmenet: Minden tőle kívüleső szomszédosba el kell jutni. Ha ez nem megy, akkor a legértékesebb (legmagasabb eddig értékkel 
				//rendelkező) mezőkbe kell eljutni.
			if(!mar) {	//Ha nincs még az objektum értéke kiszámolva.
				
				int korulhanynincsupdate=0;	//Hány a környékén ki nem számított érték van.
				for(int i=0;i<kapcs.length;i++) {
					if(!pontok[kapcs[i]].mar) {
						korulhanynincsupdate++;
					}
				}
				if(korulhanynincsupdate<2) {	//Ha max. 1 ki nem számított szomszédos pontja van, akkor folytatódik.
					int updated=0;	//Körülötte hány kiszámított pontja van.
					for(int i=0;i<kapcs.length;i++) {
						if(pontok[kapcs[i]].mar) {
							updated++;
						}
					}
					if(updated>hany-1) {
						//Ha nem lehet eljutni az összesbe
						int kapcsolatokban[] = new int[kapcs.length];
						for(int i=0;i<kapcs.length;i++) {
							if(pontok[kapcs[i]].mar)
								kapcsolatokban[i]=pontok[kapcs[i]].eddig;
							//Eddig értékek másolása
						}
						int osszeg=0;
						for(int i=0;i<hany-1;i++) {
							//Maximális értékek kiszámolása
							int max=-1;
							int hol=0;
							for(int j=0;j<kapcsolatokban.length;j++) {
								if(max<kapcsolatokban[j]) {
									max=kapcsolatokban[j];
									hol=j;
								}
							}
							osszeg+=max+2;	//Az oda-vissza út is
							kapcsolatokban[hol]=-1;
						}
						tortent = true;	//Jelzés, hogy változott
						eddig=osszeg;	//eddig érték beállítása
						publichany=1;	//publichany beállítása
						mar=true;	//Változás történt beállítása
					} else {
						int osszeg=0;	//Szomszédos eddig beállított eddig értékek hozzáadása
						for(int i=0;i<kapcs.length;i++) {
							if(pontok[kapcs[i]].mar)
								osszeg+=pontok[kapcs[i]].eddig+2;	//Oda-vissza út
						}
						
						int kapcsolatokban[] = new int[kapcs.length];
						for(int i=0;i<kapcs.length;i++) {	//Körülötte lévők publichany értékeknek másolása
							if(pontok[kapcs[i]].mar)
								kapcsolatokban[i]=pontok[kapcs[i]].publichany;
							
						}
						int maradthany=hany-kapcs.length+korulhanynincsupdate;
						for(int i=0;i<kapcsolatokban.length;i++) {	//Megpróbál a szomszédos pontokkal oda-vissza menni az összes lehetséges módon.
							while(kapcsolatokban[i]>1&&maradthany>1) {
								kapcsolatokban[i]--;
								maradthany--;
								osszeg+=2;
							}
						}
						tortent = true;	//Jelzés, hogy változott
						eddig=osszeg;	//eddig érték beállítása
						publichany=maradthany;	//publichany beállítása (annyi, amennyi út hátramarad az oda-vissza utakból)
						mar=true;	//Változás történt beállítása
					}
				}
			}
		}
		
		public void InduloUpdate() {
			//Gondolatmenet: Minden tőle kívüleső szomszédosba el kell jutni. Ha ez nem megy, akkor a legértékesebb (legmagasabb eddig értékkel 
			//rendelkező) mezőkbe kell eljutni.
		if(!mar) {	//Ha nincs még az objektum értéke kiszámolva.
			
			int korulhanynincsupdate=0;	//Hány a környékén ki nem számított érték van.
			for(int i=0;i<kapcs.length;i++) {
				if(!pontok[kapcs[i]].mar) {
					korulhanynincsupdate++;
				}
			}
			if(korulhanynincsupdate<2) {	//Ha max. 1 ki nem számított szomszédos pontja van, akkor folytatódik.
				int updated=0;	//Körülötte hány kiszámított pontja van.
				for(int i=0;i<kapcs.length;i++) {
					if(pontok[kapcs[i]].mar) {
						updated++;
					}
				}
				if(updated>hany) {
					//Ha nem lehet eljutni az összesbe
					int kapcsolatokban[] = new int[kapcs.length];
					for(int i=0;i<kapcs.length;i++) {
						if(pontok[kapcs[i]].mar)
							kapcsolatokban[i]=pontok[kapcs[i]].eddig;
						//Eddig értékek másolása
					}
					int osszeg=0;
					for(int i=0;i<hany;i++) {
						//Maximális értékek kiszámolása
						int max=-1;
						int hol=0;
						for(int j=0;j<kapcsolatokban.length;j++) {
							if(max<kapcsolatokban[j]) {
								max=kapcsolatokban[j];
								hol=j;
							}
						}
						osszeg+=max+2;	//Az oda-vissza út is
						kapcsolatokban[hol]=-1;
					}
					tortent = true;	//Jelzés, hogy változott
					eddig=osszeg;	//eddig érték beállítása
					publichany=0;	//publichany beállítása
					mar=true;	//Változás történt beállítása
				} else {
					int osszeg=0;	//Szomszédos eddig beállított eddig értékek hozzáadása
					for(int i=0;i<kapcs.length;i++) {
						if(pontok[kapcs[i]].mar)
							osszeg+=pontok[kapcs[i]].eddig+2;	//Oda-vissza út
					}
					
					int kapcsolatokban[] = new int[kapcs.length];
					for(int i=0;i<kapcs.length;i++) {	//Körülötte lévők publichany értékeknek másolása
						if(pontok[kapcs[i]].mar)
							kapcsolatokban[i]=pontok[kapcs[i]].publichany;
						
					}
					int maradthany=hany-kapcs.length+korulhanynincsupdate;
					for(int i=0;i<kapcsolatokban.length;i++) {	//Megpróbál a szomszédos pontokkal oda-vissza menni az összes lehetséges módon.
						while(kapcsolatokban[i]>1&&maradthany>0) {
							kapcsolatokban[i]--;
							maradthany--;
							osszeg+=2;
						}
					}
					tortent = true;	//Jelzés, hogy változott
					eddig=osszeg;	//eddig érték beállítása
					publichany=maradthany;	//publichany beállítása (annyi, amennyi út hátramarad az oda-vissza utakból)
					mar=true;	//Változás történt beállítása
				}
			}
		}
		}
		
		static boolean updateAll() {
			tortent=false;	//Végig megy az összes Pont objektumon és végrehejtja az Update() parancsot
			for(int i=1;i<pontok.length;i++) {
				pontok[i].update();
			}
			return tortent;
		}
	}

}