bzoj1063

仔细观察可以发现，这个规划路径很像树链剖分

树链剖分的经典定理：任意一个点到根的所经过轻边不超过logn

而这个规划路径所走公路相当于轻边，也就是说，不便利度不会很大

那么直接dp即可，设f[x,i,k]表示以x为根的子树，不便利度不超过i，且x向下连了k[0,2]条边的方案数

根据增量法的思想，不难从孩子转移到父亲

注意这里取模等于0和没有方案的区别要注意一下

type node=record
       po,next:longint;
     end;

var e:array[0..400010] of node;
    f:array[0..100010,-1..12,0..2] of int64;
    p:array[0..100010] of longint;
    v:array[0..100010] of boolean;
    mo,n,m,i,x,y,len:longint;

procedure add(x,y:longint);
  begin
    inc(len);
    e[len].po:=y;
    e[len].next:=p[x];
    p[x]:=len;
  end;

function get(x:int64):int64;
  begin
    if (x>0) and (x mod mo=0) then exit(mo)
    else exit(x mod mo);
  end;

procedure dfs(x:longint);
  var i,y,j:longint;
      s1,s0:int64;
  begin
    for i:=0 to 12 do
      f[x,i,0]:=1;
    i:=p[x];
    v[x]:=true;
    while i<>0 do
    begin
      y:=e[i].po;
      if not v[y] then
      begin
        dfs(y);
        for j:=0 to 12 do
        begin
          s1:=f[y,j,0]+f[y,j,1];
          s0:=f[y,j-1,0]+f[y,j-1,1]+f[y,j-1,2];
          f[x,j,2]:=get(f[x,j,2]*s0+f[x,j,1]*s1);
          f[x,j,1]:=get(f[x,j,1]*s0+f[x,j,0]*s1);
          f[x,j,0]:=get(f[x,j,0]*s0);
        end;
      end;
      i:=e[i].next;
    end;
  end;

begin
  readln(n,m,mo);
  for i:=1 to m do
  begin
    readln(x,y);
    add(x,y);
    add(y,x);
  end;
  if m<n-1 then
  begin
    writeln(-1);
    writeln(-1);
    halt;
  end;
  dfs(1);
  for i:=0 to 12 do
    if f[1,i,0]+f[1,i,1]+f[1,i,2]>0 then
    begin
      writeln(i);
      writeln((f[1,i,0]+f[1,i,1]+f[1,i,2]) mod mo);
      halt;
    end;
  writeln(-1);
  writeln(-1);
end.