{
TASK:VAGONAI
LANG:PASCAL
}
program vagonai;
  const PR = 'vagon.dat';
        RZ = 'vagon.rez';
        MX_V = 100; { maksimalus vagonų skaičius }
        MX_U = MX_V div 2;
        MX = MX_V; { didesnis iš MX_V, MX_U }

  type masyvas = array [0..MX] of integer;
       kv_masyvas = array [0..MX] of masyvas;

  { žemiau aprašyti globalieji kintamieji }
  var Va: masyvas; { traukinio aprašymas }
      Uz: kv_masyvas; { užsakymai; koks klientas kiek ko užsakė }

  procedure palikti (var uz_i: masyvas; { i-ojo kliento užsakymas }
                     i, { kliento numeris }
                     nr: integer; { jam paliekamo vagono numeris }
                     var vag, { ar tik vagonas užsakovui }
                     uzsak: { ar įvykdytas užsakymas } integer);
  begin
    if (uzsak = 0) and (uz_i[Va[nr]] > 0)
       { jei neįvykdytas užsakymas ir tas vagonas užsakytas }
       then begin
              uz_i[Va[nr]] := uz_i[Va[nr]] - 1;
              uz_i[0] := uz_i[0] - 1;
              if uz_i[0] = 0
                 then begin
                        uzsak := 1;
                        vag := 0;
                      end
                 else vag := vag + 1;
            end
  end; { palikti }

  procedure inicializuoti (var mas: kv_masyvas);
     var i, j: integer;
  begin
    for i := 0 to MX do
      for j := 0 to MX do
         mas[i, j] := 0;
    end; { inicializuoti }


  procedure skaiciuoti (V, U: integer; var mu, mv: integer { maks. uzs ir maks. vag });
   { randa maksimalų ispildytų užsakymų bei vagonų skaičius mu ir mv }
    var i, j, nr, vag, uzsak, max_u, max_v: integer;
        uz_i: masyvas; { i-ojo kliento užsakymas }
        IU: kv_masyvas; { dinaminė lent - išpildyti užsak }
        IV: kv_masyvas; { dinamine lent - išpildyti vagonai }
  begin
    inicializuoti (IU);
    inicializuoti (IV);
    for i := 1 to U do { i-tajam klientui }
      for j := 1 to V do  { paskutinis paliktas vagonas yra j-asis }
        if ((i-1)*2 < j-1) and { bent po du vagonus ankstesniems klientams }
           ((V-j) >= (U-i)*2) { bent po du vagonus tolesniems klientams }
           { liko vag. } { reikia vag. }
           then begin { čia galima kirpti }
                  uz_i := Uz[i]; { i-ojo kliento užsakymas }
                  max_u := 0; max_v := 0;
                  vag := 0; uzsak := 0;
                  { j-asis vagonas paliekamas klientui }
                  palikti (uz_i, i, j, vag, uzsak);
                  for nr := j-1 downto 2*(i-1)+1 do
                      { pirmojo užsak. paliekamo vagono numeris gali buti nr }
                    begin
                      { ar ivykdomas užsak ir kiek vagonu palikta
                        i-ajam klientui }
                      palikti (uz_i, i, nr, vag, uzsak);
                      { atnaujinamos lenteles }
                      if IU[i-1, nr-1] + uzsak > max_u
                         then begin
                                max_u := IU[i-1, nr-1] + uzsak;
                                max_v := IV[i-1, nr-1] + vag;
                              end;
                      if (IU[i-1, nr-1] + uzsak = max_u)  and
                         (IV[i-1, nr-1] + vag > max_v)
                         then max_v := IV[i-1, nr-1] + vag;
                    end;
                   IV[i, j] := max_v;
                   IU[i, j] := max_u;
               end
           else begin { čia kirpti negalima }
                  IV[i, j] := -1;
                  IU[i, j] := -1
                end;
     { randamas rezultatas }
     mu := 0; mv := 0;
     for i := 2*(U-1)+1 to V do
       begin
         if IU[U, i] > mu
            then begin
                   mu := IU[U, I];
                   mv := IV[U, I];
                 end;
         if (IU[U, i] = mu) and (IV[U, i] > mv)
            then mv := IV[U, I];
        end;
  end; { skaičiuoti }

  procedure skaityti (var P, V, U: integer; var Va: masyvas;
                      var Uz: kv_masyvas);
    var f: text;
        i, j, nr: integer;
  begin
    inicializuoti (Uz);
    assign (f, PR);
    reset (f);
    readln (f, P, V);
    for i := 1 to V do
      read (f, Va[i]);
    readln (f, U);
    for i := 1 to U do
      begin
        read (f, Uz[i, 0]); { užsakomų vagonų skaičius }
        for j := 1 to Uz[i, 0] do
          begin
             read (f, nr);
             Uz[i, nr] := Uz[i, nr] + 1;
          end;
      end;
    close (f);
  end; { skaityti }

  procedure spausdinti (mu, mv: integer);
    var f: text;
  begin
    assign (f, RZ);
    rewrite (f);
    writeln (f, mu, ' ', mv);
    close (f);
  end; { spausdinti }

  var P, V, U, mu, mv: integer;

begin
  skaityti (P, V, U, Va, Uz);
  skaiciuoti (V, U, mu, mv);
  spausdinti (mu, mv);
end.