program p_e;
const
  maxn=20000+1;
type
  tgroup=record father,members:integer;end;
  ttree=array[1..maxn]of tgroup;
  tstack=array[1..maxn]of integer;
  pnode=^tnode;
  tnode=record node:integer; next:pnode; end;
  plist=array[1..maxn]of pnode;
var
  n,k:longint;
  hands:longint;
  groups:ttree;
  ngroups:integer;
  stack:tstack;
  startstack,endstack:integer;
  list:plist;

procedure Add(x,y:integer);
var
  p:pnode;
begin
  new(p);
  p^.node:=y;
  p^.next:=list[x];
  list[x]:=p;
end;

procedure read_data;
var
  ng:integer;
  index:integer;
  i:integer;
  son,mem:integer;
begin
  readln(n,k);
  ngroups:=1;
  groups[1].father:=0;
  groups[1].members:=n;
  fillchar(list,sizeof(list),0);
  while not eof do
  begin
    read(index);
    read(ng);
    for i:=1 to ng do
    begin
      read(son,mem);
      Add(index,son);
      inc(ng);
      groups[son].father:=index;
      groups[son].members:=mem;
    end;
  end;
end;

procedure EliminateOneCouple(node:integer);
begin
  if node=0 then
    exit;
  dec(groups[node].members);
  EliminateOneCouple(groups[node].father);
end;

procedure eliminate_couples;
var
  p:pnode;
begin
  startstack:=1;
  endstack:=1;
  stack[1]:=1;
  while startstack<=endstack do
  begin
    p:=list[stack[startstack]];
    if (p=nil) and (p^.node=2) then
      EliminateOneCouple(stack[startstack])
    else
      while p<>nil do
      begin
        inc(endstack);
        stack[endstack]:=p^.node;
        p:=p^.next;
      end;
    inc(startstack);
  end;
end;

procedure get_handshackes;
var
  p:pnode;
  current_shackes:longint;
begin
  fillchar(stack,sizeof(stack),0);
  startstack:=1;
  endstack:=1;
  stack[1]:=1;
  while startstack<=endstack do
  begin
    p:=list[stack[startstack]];
    current_shackes:=1;
    if p=nil then current_shackes:=0;
    while p<>nil do
    begin
      inc(endstack);
      stack[endstack]:=p^.node;
      current_shackes:=current_shackes*groups[p^.node].members;
      p:=p^.next;
    end;
  inc(startstack);
  inc(hands,current_shackes);
  end;
end;

procedure write_hands;
begin
  writeln(hands);
end;

begin
  read_data;
  eliminate_couples;
  get_handshackes;
  write_hands;
end.

every body handshakes all else his couple
so
n*(n-1) div 2
-
k (couples doesnt handshake eachother)!
-->

Var
  n,k:integer;
begin
  readln(n,k);
  writeln(((n*(n-1)) div 2) -k);
end.

Aidin_n7

the difficulty rangering here is absolutely uncorrect and unjust

Edited by author 31.01.2019 04:21

Does it matte how many couples there exist? And, eventually, when a
group of 10 hobbits remains unsplit, do I have to split it? I mean,
it's possible for some hobbits o remain unsplitted..... what should I
do with them?

Someone can explain the example test case and how this work for me? I read this problem many many times but still can't understand what this mean :(

Can anybody tell me for what description of groups is given to us?

solition

You can solve this problem using simple expression of n and k. Other
numbers are useless.