【大二最后两题】Hrbust 2064 萌萌哒十五酱的宠物~【思维+树链剖分 / 树上倍增LCA】

最新推荐文章于 2021-10-22 23:39:53 发布

mengxiang000000

最新推荐文章于 2021-10-22 23:39:53 发布

阅读量495

点赞数

CC 4.0 BY-SA版权

分类专栏：树链剖分线段树最近公共祖先LCA 文章标签： Hrbust 2064

本文链接：https://blog.youkuaiyun.com/mengxiang000000/article/details/77622108

线段树同时被 3 个专栏收录

46 篇文章

订阅专栏

最近公共祖先LCA

9 篇文章

订阅专栏

树链剖分

7 篇文章

订阅专栏

本篇介绍了如何通过树链剖分和树上倍增LCA算法判断宠物虫在树上行走时能否用经过的树枝构成三角形的问题。文章提供了完整的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

萌萌哒十五酱的宠物~

Time Limit: 2000 MS

Memory Limit: 32768 K

Total Submit: 43(15 users)

Total Accepted: 19(13 users)

Rating:

Special Judge: No

Description

    十五酱养了一只很可爱的宠物。。。。。。
    一只虫子。。。。TAT
    这只虫子特别喜欢爬树。。。。。它在这棵树上生活了很久，对它的构造了如指掌。所以它在树上从来都是走最短路，不会绕路。它还还特别喜欢三角形，所以当它在树上爬来爬去的时候总会在想，如果把刚才爬过的那几根树枝/树干锯下来，能不能从中选三根出来拼成一个三角形呢？

Input

    多组数据
    每组数据第一行包含一个整数 N（N<=100000），表示树上节点的个数（从 1 到 N 标号）。
    接下来的 N-1 行包含三个整数 a, b, len（1<=a<=N,1<=b<=N,1<=len<=10^9），表示有一根长度为 len 的树枝/树干在节点 a 和节点 b 之间。
    接下来一行包含一个整数 M（M<=100000），表示询问数。
    接下来M行每行两个整数 S, T，表示毛毛虫从 S 爬行到了 T，询问这段路程中的树枝/树干是否能拼成三角形。

Output

    多组数据

    对于每个询问输出一行，包含"Yes"或“No”，表示是否可以拼成三角形。

Sample Input

Sample Output

No

Yes

Hint

十五酱最萌了昂~

Source

HCPC2014校赛训练赛 6

题保证每条边没有重复

思路：

我们知道，如果拿出一堆边并且不能构成三角形的话，那么这些数一定是类似斐波那契这样去排列的，我们仔细分析一下不难估计出，如果一起拿出50条边，那么就一定能够组成三角形。我们为了保险，可以设定这个数字为100.

那么我们求出x到y两点之间有多少条边即可。

如果边数大于100.那么结果就是Yes，否则我们暴力向上爬即可，然后将从x到y路径上的所有边的权值按照从小到大排序然后暴力判定是否存在三条边构成三角形即可。

我们这里可以树链剖分去做也可以树上倍增LCA去做。这里给出两种做法。

Ac代码（剖分）：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct node
{
    int from;
    int to;
    int w;
    int next;
}e[250000];
int val[150000];
int head[150000];
int n,cont;
void add(int from,int to,int w)
{
    e[cont].to=to;
    e[cont].w=w;
    e[cont].next=head[from];
    head[from]=cont++;
}
#define lson l,m,rt*2
#define rson m+1,r,rt*2+1
int tree[155000*10];
void pushup(int rt)
{
    tree[rt]=tree[rt<<1]+tree[rt<<1|1];
}
void update(int L,int R,int c,int l,int r,int rt)
{
    if(L<=l&&r<=R)//覆盖的是区间~
    {
        tree[rt]=c;
        return ;
    }
    int m=(l+r)/2;
    if(L<=m)
    {
        update(L,R,c,lson);
    }
    if(m<R)
    {
        update(L,R,c,rson);
    }
    pushup(rt);
}
int Query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        return tree[rt];
    }
    else
    {
        int m=(l+r)>>1;
        int ans=0;
        if(L<=m)
        {
            ans+=Query(L,R,lson);
        }
        if(m<R)
        {
            ans+=Query(L,R,rson);
        }
        pushup(rt);
        return ans;
    }
}
void build( int l ,int r , int rt )
{
    if( l == r )
    {
        tree[rt]=0;
        return ;
    }
    else
    {
        int m = (l+r)>>1 ;
        build(lson) ;
        build(rson) ;
        pushup(rt) ;
        return ;
    }
}
int cnt;
int depth[150000];
int son[150000];
int fa[150000];
int size[150000];
int dfn[150000];
int Top[150000];
void Dfs(int u,int from,int d)
{
    size[u]=1;fa[u]=from;son[u]=-1;depth[u]=d;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(v==from)continue;
        Dfs(v,u,d+1);
        size[u]+=size[v];
        if(son[u]==-1||size[v]>size[son[u]])
        {
            son[u]=v;
        }
    }
}
void Dfs2(int u,int from,int top)
{
    Top[u]=top;dfn[u]=++cnt;
    if(son[u]!=-1)Dfs2(son[u],u,top);
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(v==from||v==son[u])continue;
        Dfs2(v,u,v);
    }
}
void Slove2(int x,int y)
{
    int cnt=0;
    int path[500];
    while(x!=y)
    {
        if(depth[x]<depth[y])swap(x,y);
        path[cnt++]=val[x];
        x=fa[x];
    }
    int flag=0;
    sort(path,path+cnt);
    for(int i=2;i<cnt;i++)
    {
        if(path[i-2]+path[i-1]>path[i])flag=1;
    }
    if(flag==1)printf("Yes\n");
    else printf("No\n");
}
void Slove(int x,int y)
{
    int prex=x,prey=y;
    int sum=0;
    int fx=Top[x],fy=Top[y];
    while(fx!=fy)
    {
        if(depth[fx]<depth[fy])
        {
            swap(fx,fy);swap(x,y);
        }
        sum+=Query(dfn[fx],fx,1,n,1);
        x=fa[fx];fx=Top[x];
    }
    if(depth[x]<depth[y])swap(x,y);
    if(x!=y)
    sum+=Query(dfn[son[y]],dfn[x],1,n,1);
    if(sum>=100)printf("Yes\n");
    else Slove2(prex,prey);
}
int xx[150000],yy[150000],ww[150000];
int main()
{
    while(~scanf("%d",&n))
    {
        cnt=0;
        cont=0;
        memset(head,-1,sizeof(head));
        for(int i=1;i<=n-1;i++)
        {
            int x,y,w;scanf("%d%d%d",&x,&y,&w);
            xx[i]=x;yy[i]=y;ww[i]=w;
            add(x,y,w);
            add(y,x,w);
        }
        Dfs(1,-1,1);
        Dfs2(1,-1,1);
        build(1,n,1);

        for(int i=1;i<=n-1;i++)
        {
            if(depth[xx[i]]<depth[yy[i]])swap(xx[i],yy[i]);
            val[xx[i]]=ww[i];
        }
        for(int i=2;i<=n;i++)update(dfn[i],dfn[i],1,1,n,1);
        int q;scanf("%d",&q);
        while(q--)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            Slove(x,y);
        }
    }
}

Ac代码（树上倍增）：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
using namespace std;
#define N 100500
struct node
{
    int from;
    int to;
    int w;
    int next;
}e[250000];
int head[150000];
int val[150000];
int xx[150000],yy[150000],ww[150000];
int p[150000][20];
int d[150000];
int dist[150000];
int fa[150000];
int n,cont;
void add(int from,int to,int w)
{
    e[cont].to=to;
    e[cont].w=w;
    e[cont].next=head[from];
    head[from]=cont++;
}
void Dfs(int u,int from)
{
    fa[u]=from;
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(v==from)continue;
        d[v]=d[u]+1;
        dist[v]=dist[u]+1;
        p[v][0]=u;
        Dfs(v,u);
    }
}
void init()
{
    for(int j=1;(1<<j)<=n;j++)
    {
        for(int i=1;i<=n;i++)
        {
            p[i][j]=p[p[i][j-1]][j-1];
        }
    }
}
int Lca(int x,int y)
{
    if(d[x]>d[y])swap(x,y);
    int f=d[y]-d[x];
    for(int i=0;(1<<i)<=f;i++)
    {
        if((1<<i)&f)y=p[y][i];
    }
    if(x!=y)
    {
        for(int i=(int)log2(N);i>=0;i--)
        {
            if(p[x][i]!=p[y][i])
            {
                x=p[x][i];
                y=p[y][i];
            }
        }
        x=p[x][0];
    }
    return x;
}
void Slove(int x,int y)
{
    int cnt=0;
    int path[500];
    while(x!=y)
    {
        if(d[x]<d[y])swap(x,y);
        path[cnt++]=val[x];
        x=fa[x];
    }
    int flag=0;
    sort(path,path+cnt);
    for(int i=2;i<cnt;i++)
    {
        if(path[i-2]+path[i-1]>path[i])flag=1;
    }
    if(flag==1)printf("Yes\n");
    else printf("No\n");
}
int main()
{
    while(~scanf("%d",&n))
    {
        cont=0;
        memset(d,0,sizeof(d));
        memset(head,-1,sizeof(head));
        for(int i=1;i<=n-1;i++)
        {
            int x,y,w;scanf("%d%d%d",&x,&y,&w);
            xx[i]=x;yy[i]=y;ww[i]=w;
            add(x,y,w);
            add(y,x,w);
        }
        Dfs(1,-1);
        init();
        for(int i=1;i<=n-1;i++)
        {
            if(d[xx[i]]<d[yy[i]])swap(xx[i],yy[i]);
            val[xx[i]]=ww[i];
        }

        int q;scanf("%d",&q);
        while(q--)
        {
            int x,y;scanf("%d%d",&x,&y);
            int D=dist[x]+dist[y]-2*dist[Lca(x,y)];
            if(D>=100)printf("Yes\n");
            else
            {
                Slove(x,y);
            }
        }
    }
}