【BZOJ4474】isomorphism（树的同构，哈希）

题意：一个无向树的度数为 2的结点称为假结点，其它结点称为真结点。一个无向树的简化树
其结点由原树的全体真结点组成，两个真结点之间有边当且仅当它们在原树中有边，或者在
原树中有一条联结这两个结点的路，其中间节点全是假结点。两个无向树各自的简化树如果
同构，即存在结点之间的一一对应，使得在一个树中的任意两个结点之间有边当且仅当它们
的对应结点在另一个树中有边，则称原来的两个无向树实质同构。给定若干个无向树，将相
互实质同构的无向树只保留一个其余删除。统计剩下的相互不实质同构的无向树个数，并将
它们的简化树结点个数从小到大输出。

cas<=20 n<=10000

思路：把很久以前在另一个地方写的题解搬过来

定义题。做法请看题目。

删除假节点并连边：先按输入构图并统计每个点的度数 找一个度不为2的点做一遍dfs

if d[v]=2 f[find(u)]=f[find(v)]

做完之后重连所有f[x[i]]<>f[y[i]]的边

同构：

哈希，将点上的哈希初值都=1，对于点u，取与u相连的点权V并排序，随意哈希作为新的哈希值。迭代10000000000000000000000000000000次。最后只需判断哈希值是否相等。

const mo=1000000007;
var head,vet,next,d,b,x,y,e1,q,f:array[0..20000]of longint;
    hash,s,c,h:array[1..20000]of int64;
    cas,v1,e,v,i,tot,len,n,j,k,ans:longint;
    tmp:int64;
    p:boolean;
  
procedure qsort(l,r:longint);
var i,j:longint;
    t,mid:int64;
begin
 i:=l; j:=r; mid:=q[(l+r)>>1];
 repeat
  while mid>q[i] do inc(i);
  while mid<q[j] do dec(j);
  if i<=j then
  begin
   t:=q[i]; q[i]:=q[j]; q[j]:=t;
   inc(i); dec(j);
  end;
 until i>j;
 if l<j then qsort(l,j);
 if i<r then qsort(i,r);
end;
  
function find(k:longint):longint;
begin
 if f[k]<>k then f[k]:=find(f[k]);
 find:=f[k];
end;
  
procedure add(a,b:longint);
begin
 inc(tot);
 next[tot]:=head[a];
 vet[tot]:=b;
 head[a]:=tot;
end;
  
procedure dfs(u,fa:longint);
var e,v:longint;
begin
 e:=head[u];
 while e<>0 do
 begin
  v:=vet[e];
  if v<>fa then
  begin
   if d[v]=2 then f[find(v)]:=f[find(u)];
   dfs(v,u);
  end;
  e:=next[e];
 end;
end;
  
begin
   
 readln(cas);
  
 for v1:=1 to cas do
 begin
  read(n);
  fillchar(head,sizeof(head),0);
  fillchar(b,sizeof(b),0);
  fillchar(d,sizeof(d),0);
  for i:=1 to n do hash[i]:=1;
  for i:=1 to n do f[i]:=i;
  tot:=0;
  for i:=1 to n-1 do
  begin
   read(x[i],y[i]);
   inc(d[x[i]]); inc(d[y[i]]);
   add(x[i],y[i]);
   add(y[i],x[i]);
  end;
  for i:=1 to n do
   if d[i]<>2 then
   begin
    dfs(i,-1);
    break;
   end;
  tot:=0;
  fillchar(head,sizeof(head),0);
  
  
  for i:=1 to n-1 do
   if f[x[i]]<>f[y[i]] then
   begin
    b[f[x[i]]]:=1; b[f[y[i]]]:=1;
    add(f[x[i]],f[y[i]]);
    add(f[y[i]],f[x[i]]);
   end;
  for i:=1 to n do
   if d[i]<>2 then inc(e1[v1]);
  for i:=1 to 2 do
  begin
   for j:=1 to n do h[j]:=hash[j];
   for j:=1 to n do
    if b[j]=1 then
    begin
     e:=head[j];
     len:=0;
     while e<>0 do
     begin
      v:=vet[e];
      inc(len); q[len]:=h[v];
      e:=next[e];
     end;
     if len>0 then qsort(1,len);
     tmp:=0;
     for k:=1 to len do tmp:=(tmp*10003+q[k]) mod mo;
     hash[j]:=tmp;
  
    end;
  end;
  len:=0;
  for i:=1 to n do
   if b[i]=1 then begin inc(len); q[len]:=hash[i]; end;
  if len>0 then qsort(1,len);
  tmp:=0;
  for i:=1 to len do tmp:=(tmp*10003+q[i]) mod mo;
  
  s[v1]:=tmp;
 end;
 for i:=1 to cas do
 begin
  p:=true;
  for j:=1 to i-1 do
   if s[i]=s[j] then
   begin
    p:=false; break;
   end;
  if p then begin inc(ans); c[ans]:=e1[i]; end;
 end;
 for i:=1 to ans do q[i]:=c[i];
 qsort(1,ans);
 writeln(ans);
 for i:=1 to ans-1 do write(q[i],' ');
 write(q[ans]);
  
end.