洛谷【图论2-1】基础树上问题做题总结

最新推荐文章于 2022-01-25 22:34:35 发布
最新推荐文章于 2022-01-25 22:34:35 发布
阅读量392 收藏 4
点赞数
分类专栏： 洛谷题单总结 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45677913/article/details/105223292
版权

原题单连接：【图论2-1】基础树上问题

这两天写了一下洛谷基础树上题单，小小的做一个总结，不然又忘了，收获还是有的，还有两题没写，一题是原来在牛客看题解做过了，还有一题（P5666 树的重心）感觉有点难，后面再补，感觉自己做的题型还是太少了，慢慢来吧。

P5836 [USACO19DEC]Milk Visits S
这道题应该是最简单的一题吧，把两种牛所在的节点赋予0或者1权值，统计路径和然后与询问比较就行，这里我把G权值赋值为1；
代码如下：

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e9;
const int N=1e5+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op;
int dep[N],d[N][22],nxt[N*2],head[N*2],to[N*2],sum[N];
char s[N],c[2],ans[N];
void add(int x,int y){nxt[++T]=head[x];head[x]=T;to[T]=y;}
void dfs(int now,int fa,int dp) {
    dep[now]=dp;
    d[now][0]=fa;
    sum[now]=sum[fa]+(s[now]=='G');//因为这个布尔表达式找了很久的bug
    for(int i=1;(1<<i)<=dp;i++) {
        d[now][i]=d[d[now][i-1]][i-1];
    }
    for(int i=head[now];i;i=nxt[i]) {
        int u=to[i];
        if(u==fa)continue;
        dfs(u,now,dp+1);
    }
}
int LCA(int x,int y) {
    if(dep[x]<dep[y])swap(x,y);
    for(int i=20;i>=0;i--) {
        if(dep[d[x][i]]>=dep[y]) {
            x=d[x][i];
        }
    }
    if(x==y)return x;
    for(int i=20;i>=0;i--) {
        if(d[x][i]!=d[y][i]) {
            x=d[x][i];
            y=d[y][i];
        }
    }
    return d[x][0];
}
pair<int,int> getpair(int x,int y){//返回祖先和路径和
    int z=LCA(x,y);
    return mp(sum[x]+sum[y]-2*sum[z]+(s[z]=='G'),dep[x]+dep[y]-2*dep[z]+1);
}
void solve(){
    scanf("%d%d",&n,&m);
    scanf("%s",s+1);
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs(1,1,1);
    while(m--){
        scanf("%d%d%s",&x,&y,c);
        pair<int,int> e=getpair(x,y);
        if((c[0]=='G'&&e.fi==0)||(c[0]=='H'&&e.fi==e.se))ans[k++]='0';//如果路径和为0但是你需要1或者你需要0但是路径和等于路径节点个数（即没有0）都是不合法的，其它是合法的
        else ans[k++]='1';
    }
    for(int i=0;i<k;i++)printf("%c",ans[i]);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}

P3629 [APIO2010]巡逻

这道题感觉还是很好的，树的直径的两种求法在这道题中完美的应用出来了，由于没有过多的了解树的直径的一些性质，这道题理解了好久。

对于k=1的时候很好考虑，对于一个树，如果你添加了一条边，肯定产生了一个环，那么这个环省下来的路径就是直径的大小乘上2减1，那么如果想要环最大，那么肯定连接树直径上的两个点环长最长，所以k=1的时候求一下直径输出直径长*2-1即可（减一是因为加的那条边也要走）。

对于k=2的时候，我们肯定还是要考虑直径，第一条边还是要连接直径，关键是第二个直径带来的贡献怎么求，第二条直径分成两种情况讨论，第一种是与第一条没有公共边，那么按照第一种情况一样计算就行；第二种情况是有公共边，那么对于在第一条直径中公共边的部分收益相当于没有了，也就是公共边还要走两次，那么怎么把这种想法给体现出来呢，那就是修改边权，将第一条直径上的点的边权全部改成-1（相当于x+y-y=x,y代表公共部分，取反后他的贡献就没有了），所以这道题就是求两次直径，两次直径的求法也不同，第一条由于需要知道路径所以需要dfs求，第二条由于有负边，所以需要树形dp来求。

代码如下：

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e9;
const int N=1e5+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op,s,mx,ok;
int dp[N],path[N],tot,ans,vis[N];
vector<pair<int,int> >v[N];
void dfs1(int now,int fa,int cnt){//双dfs求直径
    if(cnt>tot){
        tot=cnt;
        s=now;
    }
    for(auto e:v[now]){
        if(e.fi==fa)continue;
        dfs1(e.fi,now,cnt+1);
    }
}
void dfs2(int now,int fa,int cnt){
    if(cnt>tot){
        tot=cnt;
        t=now;
    }
    for(auto e:v[now]){
        if(e.fi==fa)continue;
        dfs2(e.fi,now,cnt+1);
    }
}
void dfs3(int now,int fa,int cnt){//这一步求路径其实可以合并到dfs2中
    if(ok)return;
    if(cnt==tot){
        vis[s]=1;
        for(int i=1;i<=cnt;i++)vis[path[i]]=1;//把路径上的点标记
        ok=1;
        return;
    }
    for(auto e:v[now]){
        if(e.fi==fa)continue;
        path[++T]=e.fi;
        dfs3(e.fi,now,cnt+1);
        --T;
    }
}
void dfs4(int now,int fa){//树形dp求直径大小
    for(auto e:v[now]){
        if(e.fi==fa)continue;
        dfs4(e.fi,now);
        ans=max(ans,dp[now]+dp[e.fi]+e.se);
        dp[now]=max(dp[now],dp[e.fi]+e.se);
    }
}
void solve(){
    scanf("%d%d",&n,&k);
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        v[x].pb(mp(y,1));v[y].pb(mp(x,1));
    }
    dfs1(1,1,0);
    dfs2(s,s,0);
    dfs3(s,s,0);
    if(k==1){printf("%d\n",2*(n-1)-tot+1);return;}
    for(int i=1;i<=n;i++){
        if(!vis[i])continue;
        for(int j=0;j<le(v[i]);j++){
            if(vis[v[i][j].fi])v[i][j].se=-1;//如果两个点都已经被标记了，那么这条边就是第一条直径上的边
        }
    }
    dfs4(1,1);
    printf("%d\n",2*(n-1)-ans-tot+2);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}

P1395 会议

这道题由于之前做过，所以感觉还是蛮简单的。只不过理解的更深了吧。
假设我们先以1为根求完所有的节点的深度和（深度和就代表所有节点到根1位置的路径和ans），那么当根节点（假如为u）改变时（假如更换为v，其中u是v的父亲节点）对于答案的贡献分为两种情况讨论，第一种是以v为节点的子树大小，这个地方每一个节点路径值都要减1，因为他们不用到u了，此外所有的（n-siz[v]）个节点都要加上1，因为他们要到达v了，所以以v为根的总路径和就是ans+n-siz[v]-siz[v]；然后在这些和中取最小值就行。

代码如下：

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e15;
const int N=1e5+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op,id=1;
int dep[N],siz[N];
LL ans;
vector<int>v[N];
void dfs(int now,int fa,int cnt){//先统计深度和子树大小
    dep[now]=cnt;
    siz[now]=1;
    for(auto e:v[now]){
        if(e==fa)continue;
        dfs(e,now,cnt+1);
        siz[now]+=siz[e];
    }
}
void findans(int now,int fa,LL res){//dfs搜索出以每一个节点为根时的最优值
    if(ans>=res){
        if(ans>res||now<=id)id=now;
        ans=res;
    }
    for(auto e:v[now]){
        if(e==fa)continue;
        findans(e,now,n-2*siz[e]+res);
    }
}
void solve(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        v[x].pb(y);v[y].pb(x);
    }
    dfs(1,1,0);
    for(int i=1;i<=n;i++)ans+=dep[i];//以1为根的路径和
    findans(1,1,ans);
    printf("%d %lld\n",id,ans);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}

P3398 仓鼠找sugar

这道题就是LCA的应用吧，想到了就简单，求两个路径有没有相交点，可以看出若有相交点，那么要么是第一条路径上的LCA在另一条上，或者反过来，当然也可以都满足，那么怎么判断某一个点是否在一条路径上呢，那就是利用路径和（两点之间的距离等于两点到中间某一个点的距离之和）。

代码如下:

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e15;
const int N=1e5+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op,s;
int dep[N],d[N][22],nxt[N*2],head[N*2],to[N*2];
void add(int x,int y) {
    nxt[++T]=head[x];
    head[x]=T;
    to[T]=y;
}
void dfs(int now,int fa,int dp) {
    dep[now]=dp;
    d[now][0]=fa;
    for(int i=1;(1<<i)<=dp;i++) {
        d[now][i]=d[d[now][i-1]][i-1];
    }
    for(int i=head[now];i;i=nxt[i]) {
        int u=to[i];
        if(u==fa)continue;
        dfs(u,now,dp+1);
    }
}
int LCA(int x,int y) {
    if(dep[x]<dep[y])swap(x,y);
    for(int i=20;i>=0;i--) {
        if(dep[d[x][i]]>=dep[y]) {
            x=d[x][i];
        }
    }
    if(x==y)return x;
    for(int i=20;i>=0;i--) {
        if(d[x][i]!=d[y][i]) {
            x=d[x][i];
            y=d[y][i];
        }
    }
    return d[x][0];
}
int dis(int x,int y){//获取路径
    return dep[x]+dep[y]-2*dep[LCA(x,y)];
}
void solve(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs(1,1,1);
    while(m--){
        scanf("%d%d%d%d",&x,&y,&s,&t);
        int e1=LCA(x,y);
        int e2=LCA(s,t);
        if(dis(e1,s)+dis(e1,t)==dis(s,t)||dis(e2,x)+dis(e2,y)==dis(x,y))puts("Y");//判断LCA是否在另一条路径上
        else puts("N");
    }
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}

P4281 [AHOI2008]紧急集合 / 聚会

这道题也是和LCA联系很大了，首先我们需要理解一点，若只有两个点a，b，那么我们就只需要求两个点的LCA(a,b)就行，两点之间线段最短，那还有一个点c就是求该点到这条线段的最短距离是什么，可以看出要么选择LCA(a,c),或者选择LCA(b,c)；而且我们通过模拟发现，这三个点两两之间的LCA会有两个是相同的，并且选择的那个聚集点一定是三个LCA深度最小的那个点，那么接下来就是求三个点到聚集点的距离问题了。疑惑的是倍增LCA竟然比树剖LCA慢一点，可能我倍增写的水了吧。

代码如下：

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e15;
const int N=5e5+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op,z,xx,yy,zz;
int dep[N],nxt[N*2],head[N*2],to[N*2],f[N],siz[N],top[N],son[N],id[N];
void add(int x,int y) {
    nxt[++T]=head[x];
    head[x]=T;
    to[T]=y;
}
void dfs1(int now,int fa){
    f[now]=fa;
    siz[now]=1;
    dep[now]=dep[fa]+1;
    int mx=0;
    for(int i=head[now];i;i=nxt[i]) {
        int e=to[i];
        if(e==fa)continue;
        dfs1(e,now);
        siz[now]+=siz[e];
        if(siz[e]>siz[mx])mx=e;
    }
    if(mx)son[now]=mx;
}
void dfs2(int now,int fa){
    id[now]=++T;
    top[now]=fa;
    if(!son[now])return;
    dfs2(son[now],fa);
    for(int i=head[now];i;i=nxt[i]) {
        int e=to[i];
        if(e==fa||e==son[now]||id[e])continue;
        dfs2(e,e);
    }
}
int LCA(int x,int y) {//树剖LCA
    for(;top[x]!=top[y];dep[top[x]]>dep[top[y]]?x=f[top[x]]:y=f[top[y]]);
    return dep[x]<dep[y]?x:y;
}
int dis(int x,int y){
    int e=LCA(x,y);
    return dep[x]+dep[y]-2*dep[e];
}
void solve(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs1(1,1);
    dfs2(1,1);
    while(m--){
        scanf("%d%d%d",&x,&y,&z);
        xx=LCA(x,y);yy=LCA(x,z);zz=LCA(y,z);
        if(dep[xx]<dep[yy])swap(xx,yy);
        if(dep[xx]<dep[zz])swap(xx,zz);
        if(dep[yy]<dep[zz])swap(yy,zz);
        printf("%d %d\n",xx,dis(xx,x)+dis(xx,y)+dis(xx,z));//或者printf("%d %d\n",xx,dep[x]+dep[y]+dep[z]-dep[xx]-2*dep[zz]);
    }
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}

P5588 小猪佩奇爬树

这道题最开始看错题想了好久，看成类似子图的问题了，结果最后发现是路径，这道题也是分类讨论吧，不过我写的可能不是正解，跑的挺慢的。
首先最简单的就是没有这个颜色，那么答案就是n*(n-1)/2，其次是颜色个数只有一个的，这个也很好想，就是这个节点的子树大小乘上非子树的其它节点个数，此外不同子树之间还可以构成点对，也就是每一个子树之间两两相乘的方案数，这个计数暴力O(n^2)，可以利用前缀和变成O(n)，也可以利用数学表达式变成O(n)。

其次就是两个或者是以上的节点颜色个数了；这个分为三种情况讨论，
首先所有该颜色节点都在一条链上，这个怎么判定呢，我们取链上深度最大的节点与其它节点求LCA，那么LCA一定是与它进行LCA的节点。
其次，若不在一条链上，那么最多在两条链上（三条链就不存在点对包含所有相同颜色节点了，这个也是第三种情况）。这种情况对于答案的贡献与一条链上的情况一样，都是两个端点带来的贡献，第一种很好判断一定是深度最深和最浅的那两个。对于两条链的情况，首先我们先把节点按照深度进行排序，那么深度最大的一定是其中的一个端点，所以我们就拿这个端点x与其他相同颜色的节点y做LCA，那么如果LCA为y，那么y就在x的这条链上，反之y就在另一条链上，且y是另一条链上深度最大的节点，记录此时节点为y；接下来就是判断是否是两条链，我们分析可知若只有两条链，那么其它节点与x，y的LCA只有两种情况，要么等于自身（在x或者y这条链上），要么等于LCA(x,y)，所以我们可以以此为判断条件判断是否是两条链。

接下来就是统计两个端点带来的贡献了，也很好想，一条链上的答案就是深度较大的节点子树大小乘上除去另一个端点的子树大小，另一个端点的子树大小可以用在这条链上的端点的儿子子树大小求得（这个地方当然可以倍增求了）。两条链就更好求了，就是两个端点的子树大小相乘。

代码如下：

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e15;
const int N=1e6+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op,z,xx,yy,zz;
int dep[N],d[N][22],nxt[N*2],head[N*2],to[N*2],siz[N],f[N];
vector<int>v[N];
struct node{
    int id,dp;
    bool operator<(const node &p)const{
        return dp>p.dp;
    }
};
void add(int x,int y){nxt[++T]=head[x];head[x]=T;to[T]=y;}
void dfs(int now,int fa,int dp) {
    dep[now]=dp;
    d[now][0]=fa;
    siz[now]=1;
    f[now]=fa;
    for(int i=1;(1<<i)<=dp;i++) {
        d[now][i]=d[d[now][i-1]][i-1];
    }
    for(int i=head[now];i;i=nxt[i]) {
        int u=to[i];
        if(u==fa)continue;
        dfs(u,now,dp+1);
        siz[now]+=siz[u];
    }
}
int LCA(int x,int y) {
    if(dep[x]<dep[y])swap(x,y);
    for(int i=20;i>=0;i--) {
        if(dep[d[x][i]]>=dep[y]) {
            x=d[x][i];
        }
    }
    if(x==y)return x;
    for(int i=20;i>=0;i--) {
        if(d[x][i]!=d[y][i]) {
            x=d[x][i];
            y=d[y][i];
        }
    }
    return d[x][0];
}
LL cal(int now,int fa){//统计一个节点带来的贡献
    LL res=0,x=1;
    for(int i=head[now];i;i=nxt[i]){
        int u=to[i];
        if(u==fa)continue;
        res+=x*siz[u];
        x+=siz[u];//前缀和累乘
    }
    return res+1LL*(n-siz[now])*siz[now];//加上该点两端带来的贡献
}
LL fans(int now){//两个节点以上的答案求法
    vector<node>q;
    for(auto e:v[now])q.pb(node{e,dep[e]});
    sort(all(q));//按照深度进行排序
    int x=q[0].id,y=-1;//取最深的节点作为一个端点，找另外一个
    bool ok=true;//先判断是否是一条链
    for(auto e:v[now]){
        if(e==x)continue;
        t=LCA(e,x);
        if(t==e)continue;
        ok=false;
        y=e;//LCA不同说明是另一条链的端点
        break;
    }
    if(ok){//是一条链直接统计答案
        t=le(q);
        y=q[t-1].id;
        int te=x;
        for(int i=20;i>=0;i--)if(dep[d[te][i]]>dep[y])te=d[te][i];//倍增找y的儿子节点，且儿子节点在这条链上
        return 1LL*siz[x]*(n-siz[te]);
    }
    k=LCA(x,y);
    for(auto e:q){
        if(e.id==y||e.id==x)continue;
        int c=e.id;
        int a=LCA(c,x),b=LCA(c,y);
        if(a==c&&b==k||b==c&&a==k)continue;//判断是否满足两条链的条件
        return 0;
    }
    return 1LL*siz[x]*siz[y];
}
void solve(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        v[x].pb(i);
    }
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        add(x,y);add(y,x);
    }
    dfs(1,1,1);
    for(int i=1;i<=n;i++){
        if(le(v[i])==0)printf("%lld\n",1LL*n*(n-1)/2);
        else if(le(v[i])==1){
            printf("%lld\n",cal(v[i][0],f[v[i][0]]));
        }else {
            printf("%lld\n",fans(i));
        }
    }
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}

P5536 【XR-3】核心城市

这道题也是树直径的一种利用吧，首先若只有一个点那么这个点肯定选在直径的中点，所以我们需要双dfs求得直径和直径上的路径，所以这个时候我们需要换根为中点重新建立这棵树，那么其它的k-1个城市的选择就在中点的子树种进行选择。然后我们可以每一次放置的时候都肯定选择某一条链上深度差最大的，深度差最大肯定到根的距离最大嘛。然后我们就可以对于每一个节点统计他的子树中节点最大的深度与该节点的深度差最大是多少，然后按照这个差排序，那么排前k个的节点就是需要作为中心的节点。那么放完之后的答案就是第k+1个节点的差+1。

代码如下：

#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define le(x) ((int)(x).size())
#define LL long long
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define db printf("Here!\n");
using namespace std;
const double eps=1e-6;
const LL inf=1e15;
const int N=1e5+5;
const int M=2e6+5;
const int mod=998244353;
int n,m,k,t,T,len,x,y,op,s,mid;
int dep[N],path[N],cha[N];
vector<int>v[N];
void dfs1(int now,int fa,int cnt){
    if(cnt>len){
        len=cnt;
        s=now;
    }
    for(auto e:v[now]){
        if(e==fa)continue;
        dfs1(e,now,cnt+1);
    }
}
void dfs2(int now,int fa,int cnt){//求直径和路径中点
    path[cnt]=now;
    if(cnt>len){
        mid=path[(cnt+1)/2];
        len=cnt;
        t=now;
    }
    for(auto e:v[now]){
        if(e==fa)continue;
        dfs2(e,now,cnt+1);
    }
}
int dfs4(int now,int fa){//以中点为根建立树，并统计深度差
    dep[now]=dep[fa]+1;
    int mx=dep[now];
    for(auto e:v[now]){
        if(e==fa)continue;
        mx=max(dfs4(e,now),mx);
    }
    cha[now]=mx-dep[now];
    return mx;
}
void solve(){
    scanf("%d%d",&n,&k);
    for(int i=1;i<n;i++){
        scanf("%d%d",&x,&y);
        v[x].pb(y);v[y].pb(x);
    }
    dfs1(1,1,1);
    len=0;
    dfs2(s,s,1);
    dfs4(mid,mid);//重新建立这颗树
    sort(cha+1,cha+1+n,greater<int>());
    printf("%d\n",cha[k+1]+1);
}
int main(){
    //int o;scanf("%d",&o);
    //while(o--){
        solve();
    //}
    return 0;
}
SuperDeyang
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法竞赛学习笔记】树上问题基础-超有用的图论详解
SC_Linno的博客
11-06 418
title ：树上问题基础 tags : ACM,图论 date : 2021-11-6 author : Linno 基本概念 树的深度：从树根往下数，叶子节点所在的最大层数称为树的深度。（有教材定义不一样，看题意吧。要区分高度） 树的直径：树中两节点距离的最大值称为树的直径。 子树大小：对每一个节点的大小都等于左子树大小+右子树大小+1（自己） 节点重量：删去该节点后，所有树大小的最大值。即该节点所有子树大小的最大值称为节点重量。 求树的直径 做法1：两遍dfs const int N = 1000.
树和图的基础知识（洛谷）
m0_62593364的博客
08-14 238
用结构体存储左右儿子，dfs深度搜索遍历。邻接表存树，然后dfs或bfs遍历。代码3：纯dfs（用二维数组进行存储）代码2：bfs（和搜索与图论的。代码2：利用ASCII进行存储。代码：和上一题的代码1一样。代码：和上一题的代码1一样。代码：和上一题的代码1一样。代码1：和上一题做法一样。...
洛谷题单——【图论2-3】最小生成树
qq_46126537的博客
01-01 327
P3366 【模板】最小生成树 一道模板题，prim算法就可以过，krustal算法也是可以的嗷 这里只给出prim的结法 #include <bits/stdc++.h> using namespace std; const int N = 5010; const int INF = 0x3f3f3f3f; int n, m; int g[N][N]; int dist[N]; bool st[N]; int prim() { memset(dist, 0x3f, sizeof(dis
入门树形结构详解&&洛谷P5836题解
Cherrt的博客
04-13 568
前言 本题之所以被用于"入门树形结构详解"，是因为AC本题需要下面几个前置芝士: ①倍增优化LCA； ②树上前缀和； ③树上差分。 本篇文章适合树形结构初学者阅读。讲得详细的程度远远超过您的想象! 题面 题目描述 Farmer John 计划建造 N个农场，用 N-1条道路连接，构成一棵树（也就是说，所有农场之间都互相可以到达，并且没有环）。每个农场有一头奶牛，品种为更赛牛或荷斯坦牛之一。 Far...
洛谷基础题-P1047 [NOIP2005 普及组] 校门外的树
cmdxly的博客
01-25 715
P1047 [NOIP2005 普及组] 校门外的树 1.第一次使用暴力匹配的方法解决，只能过前两个测试点 #include<iostream> #include <cmath> #include <vector> using namespace std; #define MAX 1000 int main() { int roadLength,zoneNumber; int u_v[MAX][2]; int u,v; cin>>roadLength
图论基础----思维导图
05-29
1）内容概要 图论基础----思维导图 2）涉及知识点： 1. 图的基本概念 2. 节点的度数 3. 子图，图的运算和图的同构 4. 路与回路 5. 图的连通性 6. 图的矩阵表示 7. 赋权图及最短路径
2011-集合论与图论-期末试题1
08-03
1.设 2.集合 4. 设 5.集合 6.什么是无穷集合 7.设 8.已知 9. 若 3. 写出无向树的特征性质（至少
2012-集合论与图论-期末试题1
08-03
1. 求方程： A X 2. 设 3. 给定集合 4.在 5. 什么是可数集合 6. 图G 是欧拉图当且仅当图G 是 7. 若图G 是自补图，则它所对应的完全图
[PPT]-图论算法---最大流问题.ppt
05-29
[PPT]-图论算法---最大流问题.ppt
2005-集合论与图论-期末试题及答案1
08-03
1.设 2.设 3.设 4.设 5.设T 是一个有 6.正整数m 和 7.设 8. 具有 p 个顶点 2.将置换（ 3.设 4.设 5. 集 合 6.画出偏序集
题解 luoguP3401 【洛谷树】
lxy超超超级大蒟蒻的博客
06-07 227
传送门 半年没写树剖了，就当模板练一下 首先设根节点到iii路径上的异或和为val[i]val[i]val[i]，则iii到jjj路径的异或和为val[i]⊕val[j]val[i]\oplus val[j]val[i]⊕val[j]。 对于iii到jjj所有子路径的异或和的和，对每一位分开来考虑，对于第iii位，发现贡献就是(1<<i)×gs(0)×gs(1)(1<<i)\times gs(0)\times gs(1)(1<<i)×gs(0)×gs(1)，其中gs(x)
树形结构+思维 树的重量（洛谷 P1268）
不知所云的博客
04-07 166
树的重量 题目比较长，不放题面了； 题目比较难理解，简单来说就是给你n个叶子结点，然后给你这些点互相到达的最短距离，让你组成一颗树（这颗树唯一），求树的总路径长度（称为重量）； 这题相当思维，而且必须画图才能理解，直接说结论吧，每个叶子结点可以从原来的路径上分叉得到，加这个叶子结点带来的路径长度增加为： 这里原来的路径为（1，j），新增的叶子结点为 i ; ans=(dis(1,i)+dis(i...
NOIP树上问题总结
weixin_30493321的博客
09-12 227
这几年考了好几次树上问题： NOIP2012 疫情控制(二分答案+倍增+贪心) NOIP2013 货车运输(最大生成树+倍增) NOIP2014 联合权值(勉强算作树形dp的傻逼题) NOIP2015 运输计划(二分答案+树上差分+最近公共祖先) NOIP2016 天天爱跑步(树上差分+树上倍增) 可以说除了联合权值外都有一定的难度，(关键是我不抄题解一道也做不出来) 去年没考树上的...
2020.02.06日常总结——树上问题
ZHUYINGYE_123456的博客
02-06 303
树上dp\color{green}{树上dp}树上dp 顾名思义，即树上的dp问题。 有两种转移方式：一是从根转移到叶子，二是从叶子转移到根。在实际应用中，从叶子转移到根的方式应用的更多。 树上dp在实现起来的时候，可能需要配合贪心等其它高效的算法，甚至于线段树等高效数据结构。 代码实现起来的时候，常常用递归实现，因为树的定义就是递归定义的。同时，一定要注意不要从一个点又转移回了它的父亲，否则，...
[USACO18DEC]The Cow Gathering(洛谷-5157)(树-思维题)
Mouse_liang的博客
03-11 524
文章目录题目描述思路代码题外话 题目描述 Luogu-传送门 思路 首先我们可以发现这是棵树 然后我们可以通过分析题目发现： 如果此时走的 人 牛不是叶节点,最终会剩下至少两个单独的节点,不符合题意 所以 我们每次删除只能删除叶节点 (a,b)(a,b)(a,b) 表示 aaa 必须比 bbb 之前删 那么假设我们现在有棵树表示牛之间的关系(根节点任意)： 然后我们现在有几组 (a,b)(a,...
一类子树问题的总结
weixin_30336061的博客
03-28 120
以下问题均允许离线，根节点都为1。 prob1 : 一棵有根树，要求线性时间求出任意子树的权值和。 prob2 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的节点的权值和。 prob3 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的不同颜色种类个数，颜色数不超过1E6。 prob4 : 一颗有根数，要求O(nlogn+大常数)求出与u距离不超...
树专题经典题目+方法总结
肉丸不肉
03-12 898
一、二叉树（Binary Tree） 1.1 二叉树的遍历题目（前序、后序、中序、层次） 后序遍历 = 删除树中结点 当你删除一个节点时，你将首先删除它的左节点和它的右边的节点，然后再删除节点本身。 层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。 前中后序遍历的三种方法：递归、迭代、颜色标记法 层次遍历方法：使用 BFS 进行层...
决策树
holy的博客
07-20 515
转自：http://www.jianshu.com/p/fb97b21aeb1d 面试问题1：什么是决策树？ 答：决策树是一种分类和回归的基本模型，可从三个角度来理解它，即： 一棵树if-then规则的集合，该集合是决策树上的所有从根节点到叶节点的路径的集合定义在特征空间与类空间上的条件概率分布，决策树实际上是将特征空间划分成了互不相交的单元，每个从根到叶的路径对应着一个单元。决策树所表
树上分治：总结和理解
limn204的专栏
10-28 345
所以树上分治是什么呢？树上分治是解决一类树上路径计数的问题。 举个例子，我现在要知道树上有多少条路的距离小于等于K。 如果直接取点判断肯定是不行的，我们考虑一条路径，肯定有两种可能，一个是经过根节点，或者不在根节点。那我们就可以先找一个根节点，将一颗树转化成一个有根树。然后我们对以这点为中心，计算有多少个符合的路径。当然这一次计算会发现把子树上的也算进去了。删掉这个点，然后我们再遍历所有的子树，先...
c++实现：利用并查集解决图论-桥问题
最新发布
05-30
桥在图的连通性上有着非常重要的作用，因此在图论算法中经常会用到桥。 而解决桥的问题，我们可以使用并查集这种数据结构。具体步骤如下： 1. 初始化并查集，每个节点的父节点都是自己。 2. 对于每条边(u, v)，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值