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

最新推荐文章于 2020-10-11 21:47:42 发布
最新推荐文章于 2020-10-11 21:47:42 发布
阅读量243 收藏
点赞数
分类专栏： 哈希 无根树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoxinxin1234/article/details/108314326
版权

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

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

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

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

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

再套上外层的 O ( n ) O(n) O(n) ，那么时间复杂度是 O ( n 2 l o g n ) O(n^2logn) O(n2logn) 的，显然不能通过此题。

考虑如何剪枝。

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

找到重心（或者找到删除该点后使得剩下的树大小一致的点），只需要判断这个点的所有子树是否同构即可。
时间复杂度 O ( n l o g n ) O(nlogn) 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 ( n l o g n ) O(nlogn) O(nlogn)

考虑 O ( n ) O(n) O(n) 的算法。

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

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

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

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

时间复杂度： O ( n ) O(n) O(n) 但是会带一个小常数，大约 2 − 3 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;
}

_Shmily
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【树的哈希/树同构】2019-2020 ICPC, Asia Jakarta Regional Contest - F. Regular Forestation
Eliot的博客
10-31 304
题目链接https://codeforces.com/contest/1252/problem/F 题意 给出一棵树，问删去一个度大于1的节点，使得剩下的树两两同构。问剩下的树最多是多少。 题解 容易想到，能够删去的点不可能存在多个，而且删去的必然是树的重心。剩下就是个判树同构了，而这个可以直接对树进行哈希来判断。 关于树的哈希与判树同构：https://www.luogu.org/prob...
石油大 2020年秋季组队训练赛第二十五场 问题 H: Needle （FFT）
birdmanqin的博客
12-08 367
题目： 思路：就是求数组a和数组c中有多少对(i,j)，满足ai+cj==2*bk(k=1,2,3,..,nm)。将ai看作多项式的指数，num[ai]看作多项式的系数。FFT求多项式相乘，再计算答案，系数ai就是对应和为i的个数。 #include <bits/stdc++.h> #define ll long long using namespace std; const int N = 5e4+10; const int M = 9e4+10; const int base.
2019-2020 ICPC, Asia Jakarta Regional Contest H. Twin Buildings（贪心）
qq_42479630的博客
02-22 261
题目链接
【模拟&优先队列】UPC Contest2593 - 2020年秋季组队训练赛第十六场 问题 E: Elections
小明的博客
10-06 234
问题 E: Elections 时间限制: 3 Sec 内存限制: 128 MB Special Judge 题目描述 Byteburg Senate elections are coming. Usually “United Byteland”, the ruling Byteland party, takes all the seats in the Senate to ensure stability and sustainable development. But this year ther
2019-2020 ICPC Asia Jakarta Regional Contest
Mitsuha_的博客
11-04 1099
2019-2020 ICPC Asia Jakarta Regional Contest A.Copying Homework 签到,b[i]=n+1−a[i]b[i]=n+1-a[i]b[i]=n+1−a[i] B. Cleaning Robots 用d[i][j]用d[i][j]用d[i][j]表示在以iii为根节点的子树中,iii节点状态为jjj的方案数。 j=0j=0j=0，表示iii是一...
kaggle-santa-2020：“ Santa 2020-Candy Cane Contest”中的第9位解决方案
03-04
2020年圣诞老人-糖果手杖比赛 我在Kaggle竞赛解决方案，排名第9位。 基本策略 在本次比赛中，奖励是通过比较阈值和随机生成的数字来确定的。 如果我们知道阈值，就很容易计算获得奖励的概率。 但是代理商在比赛中看...
2020年CSP-S提高级初赛（第一轮）真题讲解(2022.08.21).pdf
08-22
在该资源中，我们可以看到，除了 2020 年 CSP-S 提高级初赛真题讲解外，还有多个其他年的初赛真题讲解，包括 2019 年、2018 年、2017 年、2016 年等年份的初赛真题讲解，这些讲解涵盖了多个编程语言和多个知识领域，...
umpt-2020-2021-team-tryout-contest：密歇根大学编程团队2020-2021团队试用比赛
02-14
【标题】：“umpt-2020-2021-team-tryout-contest：密歇根大学编程团队2020-2021团队试用比赛” 这个标题揭示了一个编程竞赛，由密歇根大学主办，目标是选拔优秀的编程团队成员。这可能是一个针对学生或社区成员的...
Codechef-contest-arena:该应用程序旨在模拟 Codechef 过去的比赛
05-30
Codechef-Contest-Arena关于该应用程序旨在模拟Codechef 过去的比赛。 这是应用程序的主要功能： 您可以使用您的 Codechef 帐户登录（使用 CodeChef API OAuth2） 登录后，会出现一个自动完成框，该框将接受比赛代码...
2019 2020 CSP-J CSP-S组 第1轮 初赛 答案+解析.rar
09-04
此压缩包文件包含了2019年和2020年连续两年CSP-J (入门级) 和 CSP-S (提高级) 组的第一轮初赛的答案与解析。CSP，全称为China Software Programming Contest，是由中国计算机学会（CCF）主办的一项编程能力认证考试...
Regular Forestation
Amber的博客
09-01 159
Regular Forestation 时间限制: 1 Sec 内存限制: 128 MB 题目描述 A forestation is an act of planting a bunch of trees to grow a forest, usually to replace a forest that had been cut down. Strangely enough, graph theorists have another idea on how to make a forest, i.e
upc秋季组队训练第十七场（队列+区间筛）
你数过天上的星星吗
10-11 709
问题 C: Unique Values 题目描述 Arup has to make many practice questions for his Computer Science 1 students. Since many of the questions deal with arrays, he has to generate arrays for his students. Since he doesn’t want to give them difficult practice problem
石油大--Contest2022 - 2020年秋季组队训练赛第二场--17100 Problem D、Find String in a Grid （AC自动机）
_Griefs
08-30 431
题面： 题意： 给定一个 R∗CR*CR∗C 的字符矩阵，由大写字母构成。 有 qqq 个询问，每次给定一个由大写字母构成的字符串，问这个字符串在这个字符矩阵中出现了多少次。 某个字符串在矩阵中出现定义为：这个字符串在矩阵中的存在形式是先往右匹配再往下匹配。其中往右往下的长度均可以为0。 题解： 考虑离线 qqq 个查询，将这 qqq 个查询建立 AC自动机。 然后将 R∗CR*CR∗C 的字符矩阵中的每个往右往下的串（枚举第 iii 行，枚举拐点 jjj）在 AC自动机上匹配，最后在 failfail
【upc】 2020年秋季组队训练赛第十七场 I Check List | 线段树
一只酷酷光儿的博客
10-11 343
When test driving a vehicle, you are asked to make a checkmark on a tablet. Uponinspection, you have noticed many fingerprints on the screen. Aside from the rushof disgust, you notice that the fingerprints on the screen can be represented by aseries o...
备战省赛组队训练赛第十七场(UPC)
dengxian5867的博客
05-02 149
upc:传送门 A: 　　题解[1] G: 　　题解[1] D,G,H,J,L 题解 by 鲁东大学 转载于:https://www.cnblogs.com/QLU-ACM/p/10803127.html
【CodeForces - 1252F】：Regular Forestation【树的同构】
KobeDuu
10-30 528
题目: CodeForces - 1252F：Regular Forestation 题意: 给定一颗树，你需要找到一个点，移除这个点后，剩下的子树都是同构的 笔记： 判定树是否同构，有两种方法，一是树的最小表示法，二是树哈希，最小表示法的时间空间都比较大，数据小时适用 有根树的最小表示法： 对树跑一遍括号序列，叶子节点的括号序列就是“()”，非叶子节点，先对儿子节点的括号序列从小...
Codeforces Regular Forestation(树的重心+树的同构)
一个蒟蒻的博客
11-13 175
题意： 给出一个树，让你选择一个Node−uNode-uNode−u删掉(根据树的定义，我们可以知道，只要删去的该节点的度≥2\geq2≥2，那么就可以得到degreeudegree_udegreeu​个子树。) 对于剩下的子树中，如果存在TreesTree_sTrees​和TreetTree_tTreet​，对于TreesTree_sTrees​中的 结点对(sis_isi​,sjs_jsj​)...
CodeForces1252 F.Regular Forestation（换根dp+树Hash判断树同构）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
07-14 238
题意： 给定n个点的无根树，点x是好点当且仅当： 1.x的度数大于1 2.以x为根时，x的所有子树结构相同 找到度数最大的好点，输出这个最大度数 数据范围：n<=4e3 解法： 枚举每个点作为根，计算子树是否同构即可，同构可以用树Hash来做 枚举部分用换根dp优化 ps： 这道题我的换根dp代码，写出来之后感觉有点魔性，我咋感觉好像和以前写的换根不太一样 code： #include<bits/stdc++.h> using namespace std; #define int long
webgoat-server-8.2.2.zip
最新发布
07-21
解压即可得到webgoat-server-8.2.2.jar

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值