石油大--Contest2022 - 2020年秋季组队训练赛第二场--17102 Problem F、Regular Forestation （树同构、剪枝）

题面：

题意：
给定一棵无根树，如果去掉点 $x$x 且去掉与点 $x$x 相连的边，剩下的部分是由 $k$k 棵树组成的森林，且这 $k$k 棵树同构，且 $k>1$k>1 。那么称 $x$x 是一个好的切分点。

输出去掉某一个好的切分点后最大的 $k$k。

题解：
数据量只有 $4000$4000，很容易想到解决方案可能是 $O\left(n^2\right)$O(n2) 复杂度的算法。

我们枚举每个点 $x$x，判定这个点是否是好的切分点，同时用 $k$k 更新答案。

在判断两棵树是否同构的时候，我们需要求出这两棵无根子树以每个点为根的哈希值，然后将这两个哈希值序列进行排序，如果两棵无根子树排序后的哈希值序列完全一样，那么这两棵树同构（因为如果两棵无根树同构，那么在 $A$A 树中若以某一点 $x$x 为根，那么在树 $B$B 中总能找到一点 $y$y，使得以 $x,y$x,y 为根的树同构）。这个时间复杂度是 $O\left(nlogn\right)$O(nlogn) 的，求一棵树每个点为根的哈希值是 $O\left(n\right)$O(n) 的，但是排序是 $O\left(nlogn\right)$O(nlogn) 的。

再套上外层的 $O\left(n\right)$O(n) ，那么时间复杂度是 $O\left(n^{2}logn\right)$O(n2logn) 的，显然不能通过此题。

考虑如何剪枝。

我们去掉一点 $x$x ，如果剩下的 $k$k 棵树同构，那么首先要要求剩下的 $k$k 棵树的大小一样。感性理解一下如果去掉一点 $x$x 能使剩下的 $k$k 棵树的大小一样，这样的点 $x$x 是不多的。（其实这样的点 $x$x 只能是重心且至多有一个，因为要去掉某一点后使得剩下的树的大小一样，如果重心不符合要求，那么其他点一定也不符合要求。因为在第一次写题的时候没考虑到这么多，所以将 $dfs$dfs 函数换成找重心也可以过）

找到重心（或者找到删除该点后使得剩下的树大小一致的点），只需要判断这个点的所有子树是否同构即可。
时间复杂度 $O\left(nlogn\right)$O(nlogn)

代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
#include<queue>
#include<bitset>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<set>
#include<ctime>
#define ui unsigned int
#define ll long long
#define llu unsigned ll
#define ld long double
#define pr make_pair
#define pb push_back
#define lc (cnt<<1)
#define rc (cnt<<1|1)
#define len(x) (t[(x)].r-t[(x)].l+1)
#define tmid ((l+r)>>1)
#define fhead(x) for(int i=head[(x)];i;i=nt[i])
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)>(y)?(y):(x))
using namespace std;

const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double dnf=1e18;
const double alpha=0.75;
const int mod=1e9+7;
const double eps=1e-8;
const double pi=acos(-1.0);
const int hp=13331;
const int maxn=100100;
const int maxm=100100;
const int maxp=100100;
const int up=1100;


int p[maxn],cnt=0;
bool ha[maxn];
void Prime(void)
{
    ha[1]=true;
    for(int i=2;i<maxn;i++)
    {
        if(!ha[i]) p[++cnt]=i;
        for(int j=1;j<=cnt&&i*p[j]<maxn;j++)
        {
            ha[i*p[j]]=true;
            if(i%p[j]==0) break;
        }
    }
}

int head[maxn],ver[maxn],nt[maxn],si[maxn],tot=1,n;
int d[maxn],maxx=-1,nowsi;
vector<pair<int,int> >ans;
llu f[maxn],g[maxn];
vector<llu>vc,vvc;

void add(int x,int y)
{
    ver[++tot]=y,nt[tot]=head[x],head[x]=tot;
}

void dfs(int x,int fa)
{
    si[x]=1;
    vector<int>vc;
    vc.clear();
    for(int i=head[x];i;i=nt[i])
    {
        if(ver[i]==fa) continue;
        dfs(ver[i],x);
        si[x]+=si[ver[i]];
        vc.pb(si[ver[i]]);
    }
	if(x!=1)
    	vc.pb(n-si[x]);
    if(vc.size()==1) return ;
    for(int i=1;i<vc.size();i++)
    {
        if(vc[i]!=vc[i-1])
            return ;
    }
    ans.pb(pr(-vc.size(),x));
}

void dfs1(int x,int fa)
{
    f[x]=si[x]=1;
    for(int i=head[x];i;i=nt[i])
    {
        int y=ver[i];
        if(y==fa) continue;
        dfs1(y,x);
        f[x]+=f[y]*p[si[y]];
        si[x]+=si[y];
    }
}

void dfs2(int x,int fa)
{
    vvc.pb(g[x]);
    for(int i=head[x];i;i=nt[i])
    {
        int y=ver[i];
        if(y==fa) continue;
        g[y]=f[y]+(g[x]-f[y]*p[si[y]])*p[nowsi-si[y]];
        dfs2(y,x);
    }
}

void get(void)
{
    for(int k=0;k<ans.size();k++)
    {
        if(-ans[k].first<=maxx) continue;
        int cnt=0,x=ans[k].second;
        bool flag=true;
        for(int i=head[x];i;i=nt[i])
        {
            vvc.clear();
            cnt++;
            dfs1(ver[i],x);
            g[ver[i]]=f[ver[i]];
            nowsi=si[ver[i]];
            dfs2(ver[i],x);
            sort(vvc.begin(),vvc.end());
            if(cnt==1) vc=vvc;
            else if(vc!=vvc)
            {
                flag=false;
                break;
            }
        }
        if(flag) maxx=max(maxx,cnt);
    }
}

int main(void)
{
    Prime();
    random_shuffle(p+1,p+cnt+1);
    int x,y;
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
        d[x]++,d[y]++;
    }
    dfs(1,0);
    sort(ans.begin(),ans.end());
    get();
    printf("%d\n",maxx);
    return 0;
}

上述时间复杂度为 $O\left(nlogn\right)$O(nlogn)

考虑 $O\left(n\right)$O(n) 的算法。

首先来复习一下树的重心的知识。

树的重心：找到一个点 $x$x, 以点 $x$x 为根时，其所有的子树中最大的子树节点数最少,那么这个点 $x$x 就是这棵树的重心。（以重心为根时，最大子树最小）

性质：
（1）树中所有点到某个点的距离和中，到重心的距离和是最小的，如果有两个重心，他们的距离和一样。
（2）把两棵树通过一条边相连，新的树的重心在原来两棵树重心的连线上。
（3）一棵树添加或者删除一个节点，树的重心最多只移动一条边的位置。
（4）一棵树最多有两个重心，且相邻。
（5）删除重心后所得的所有子树，节点数不超过原树的1/2。

那么我们可以得到，如果两棵无根树同构，那么他们的重心是一致的。
那么我们在判定两棵树是否同构时，可以先 $O\left(n\right)$O(n) 求出两棵树的重心（可能有两个），然后再 $O\left(n\right)$O(n) 判定两棵树是否同构即可。

时间复杂度： $O\left(n\right)$O(n) 但是会带一个小常数，大约 $2-3$2−3。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<string>
#include<queue>
#include<bitset>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<set>
#include<ctime>
#define ui unsigned int
#define ll long long
#define llu unsigned ll
#define ld long double
#define pr make_pair
#define pb push_back
#define lc (cnt<<1)
#define rc (cnt<<1|1)
#define len(x) (t[(x)].r-t[(x)].l+1)
#define tmid ((l+r)>>1)
#define fhead(x) for(int i=head[(x)];i;i=nt[i])
#define max(x,y) ((x)>(y)?(x):(y))
#define min(x,y) ((x)>(y)?(y):(x))
using namespace std;

const int inf=0x3f3f3f3f;
const ll lnf=0x3f3f3f3f3f3f3f3f;
const double dnf=1e18;
const double alpha=0.75;
const int mod=1e9+7;
const double eps=1e-8;
const double pi=acos(-1.0);
const int hp=13331;
const int maxn=100100;
const int maxm=100100;
const int maxp=100100;
const int up=1100;


int p[maxn],cnt=0;
bool ha[maxn];
void Prime(void)
{
    ha[1]=true;
    for(int i=2;i<maxn;i++)
    {
        if(!ha[i]) p[++cnt]=i;
        for(int j=1;j<=cnt&&i*p[j]<maxn;j++)
        {
            ha[i*p[j]]=true;
            if(i%p[j]==0) break;
        }
    }
}

int head[maxn],ver[maxn],nt[maxn],si[maxn],tot=1,n;
int d[maxn],ff[maxn],si1[maxn],dp[maxn],maxx=-1,nowsi,nowx;
int rt1,rt2;
vector<pair<int,int> >ans;
llu f[maxn];

void add(int x,int y)
{
    ver[++tot]=y,nt[tot]=head[x],head[x]=tot;
}

void dfs(int x,int fa)
{
    si1[x]=1;
    vector<int>vc;
    vc.clear();
    for(int i=head[x];i;i=nt[i])
    {
        if(ver[i]==fa) continue;
        ff[ver[i]]=x;
        dfs(ver[i],x);
        si1[x]+=si1[ver[i]];
        vc.pb(si1[ver[i]]);
    }
	if(x!=1)
    	vc.pb(n-si1[x]);
    if(vc.size()==1) return ;
    for(int i=1;i<vc.size();i++)
    {
        if(vc[i]!=vc[i-1])
            return ;
    }
    ans.pb(pr(-vc.size(),x));
}

void dfs1(int x,int fa)
{
    si[x]=1,dp[x]=0;
    for(int i=head[x];i;i=nt[i])
    {
        int y=ver[i];
        if(y==fa) continue;
        dfs1(y,x);
        si[x]+=si[y];
        dp[x]=max(dp[x],si[y]);
    }
    dp[x]=max(dp[x],nowsi-si[x]);
    if(rt1==0||dp[x]<dp[rt1]) rt1=x,rt2=0;
    else if(dp[x]==dp[rt1]) rt2=x;
}

void dfs2(int x,int fa)
{
    f[x]=si[x]=1;
    for(int i=head[x];i;i=nt[i])
    {
        int y=ver[i];
        if(y==fa||y==nowx) continue;
        dfs2(y,x);
        f[x]+=f[y]*p[si[y]];
        si[x]+=si[y];
    }
}



void get(void)
{
    for(int k=0;k<ans.size();k++)
    {
        if(-ans[k].first<=maxx) continue;
        int cnt=0,x=ans[k].second;
        bool flag=true;
        //虽然以下ans都初始化为0，有冲突的风险，但是这个风险还是比较小的。
        llu ans1=0,ans2=0;
        llu ansnow1=0,ansnow2=0;
        for(int i=head[x];i;i=nt[i])
        {
            ansnow1=0,ansnow2=0;
            ++cnt;
            int y=ver[i];
            if(y==ff[x]) nowsi=n-si1[x];
            else nowsi=si1[y];
            rt1=0,rt2=0;
            dfs1(ver[i],x);

            nowx=x;
            if(rt1!=0) dfs2(rt1,0),ansnow1=f[rt1];
            if(rt2!=0) dfs2(rt2,0),ansnow2=f[rt2];

            if(cnt==1) ans1=ansnow1,ans2=ansnow2;
            else if(!((ans1==ansnow1&&ans2==ansnow2)||(ans1==ansnow2&&ans2==ansnow1)))
            {
                flag=false;
                break;
            }
        }
        if(flag) maxx=max(maxx,cnt);
    }
}

int main(void)
{
    Prime();
    random_shuffle(p+1,p+cnt+1);
    int x,y;
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&x,&y);
        add(x,y);
        add(y,x);
        d[x]++,d[y]++;
    }
    dfs(1,0);
    sort(ans.begin(),ans.end());
    get();
    printf("%d\n",maxx);
    return 0;
}