【XSY2773】基因 后缀平衡树 树套树

最新推荐文章于 2024-10-08 13:47:01 发布
最新推荐文章于 2024-10-08 13:47:01 发布
阅读量88 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/ywwyww/p/8573561.html
版权

题目描述

　　有一棵树，每条边上面都有一个字母。每个点还有一个特征值\(a_i\)。

　　定义一个节点\(i\)对应的字符串为从这个点到根的路径上所有边按顺序拼接而成的字符串\(s_i\)。

　　有\(m\)次操作：

  • \(0~u~l~r\)：询问有多少个字符串\(s_i\)满足\(lcp(s_i,s_u)\geq l\)且\(a_i\leq r\)
  • \(1~f~a~c\)：新增一个点，父亲为\(f\)，到父亲的边上的字符为\(c\)。

　　强制在线。

　　\(n,m\leq 40000\)

题解

　　因为要加新的点而且要强制在线，所以只能用后缀平衡树了。

　　然后就会发现这是一道非常水的题了。

　　维护后缀平衡树，每个点再维护关键字为这个区间内每个点的特征值的一棵平衡树，也就是树套树。

　　后缀平衡树可以做到\(O(1)\)比较大小，但是这题不需要。

　　（其实\(O(1)\)求上面那个东西会跑的很快，但是我很懒。）

　　时间复杂度：\(O((n+m)\log^2 (n+m))\)

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<utility>
#include<iostream>
#include<ctime>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
int rd()
{
    int s=0,c;
    while((c=getchar())<'0'||c>'9');
    s=c-'0';
    while((c=getchar())>='0'&&c<='9')
        s=s*10+c-'0';
    return s;
}
void open(const char *s)
{
#ifndef ONLINE_JUDGE
    char str[100];
    sprintf(str,"%s.in",s);
    freopen(str,"r",stdin);
    sprintf(str,"%s.out",s);
    freopen(str,"w",stdout);
#endif
}
int id(char c)
{
    switch (c)
    {
        case 'A':return 1;
        case 'C':return 2;
        case 'G':return 3;
        case 'T':return 4;
    }
    return 0;
}
namespace mempool
{
    int a[2000010];
    int t;
    void init()
    {
        t=2000000;
        for(int i=1;i<=t;i++)
            a[i]=i;
    }
    int get()
    {
        return a[t--];
    }
    void push(int x)
    {
        a[++t]=x;
    }
}
const ll inf=0x7fffffffffffffffll;
const ull base=127;
ull pw[20];
int n,m;
int a[100010];
//ll hs[100010];
int f[100010][18];
int d[100010];
ull h[100010][18];
int lcp(int x,int y)
{
    if(d[x]>d[y])
        swap(x,y);
    int s=0;
    for(int i=16;i>=0;i--)
        if((1<<i)<=d[x])
            if(h[x][i]==h[y][i])
            {
                x=f[x][i];
                y=f[y][i];
                s+=1<<i;
            }
    return s;
}
int cmp(int x,int y)
{
    for(int i=16;i>=0;i--)
        if((1<<i)<=d[x]&&(1<<i)<=d[y])
            if(h[x][i]==h[y][i])
            {
                x=f[x][i];
                y=f[y][i];
            }
    return (h[x][0]!=h[y][0]?(h[x][0]<h[y][0]?1:-1):0);
}
namespace treap
{
    struct node
    {
        int k;
        int c[2],s;
        int v;
        int f;
        int l,r;
    };
    node a[2000010];
    int newnode()
    {
        int p=mempool::get();
        a[p].k=rand();
        a[p].v=a[p].c[0]=a[p].c[1]=a[p].s=a[p].f=a[p].l=a[p].r=0;
        return p;
    }
    void mt(int p)
    {
        a[p].s=a[a[p].c[0]].s+a[a[p].c[1]].s+1;
        a[p].r=(a[p].c[1]?a[a[p].c[1]].r:a[p].v);
        a[p].l=(a[p].c[0]?a[a[p].c[0]].l:a[p].v);
    }
    int ins(int &p,int x,int f=0)
    {
        if(!p)
        {
            p=newnode();
            a[p].v=a[p].l=a[p].r=x;
            a[p].s=1;
            a[p].f=f;
            return p;
        }
        int y;
        if(x<=a[p].v)
            y=ins(a[p].c[0],x);
        else
            y=ins(a[p].c[1],x);
        mt(p);
        return y;
    }
    void rotate(int x)
    {
        int p=a[x].f;
        int q=a[p].f;
        int ps=(x==a[p].c[1]);
        int qs=(p==a[q].c[1]);
        int c=a[x].c[ps^1];
        if(a[p].f)
            a[q].c[qs]=x;
        a[x].c[ps^1]=p;
        a[p].c[ps]=c;
        if(c)
            a[c].f=p;
        a[p].f=x;
        a[x].f=q;
        mt(p);
        mt(x);
    }
    void insert(int &p,int x)
    {
        int y=ins(p,x);
        while(a[y].f&&a[a[y].f].k>a[y].k)
            rotate(y);
        while(a[p].f)
            p=a[p].f;
    }
    void del(int &p)
    {
        if(a[p].c[0])
            del(a[p].c[0]);
        if(a[p].c[1])
            del(a[p].c[1]);
        mempool::push(p);
        p=0;
    }
    int query(int p,int v)
    {
        if(!p)
            return 0;
        if(a[p].l>v)
            return 0;
        if(a[p].r<=v)
            return a[p].s;
        if(a[p].v<=v)
            return a[a[p].c[0]].s+1+query(a[p].c[1],v);
        return query(a[p].c[0],v);
    }
    void dfs(int p,int f)
    {
        a[p].f=f;
        if(a[p].c[0])
            dfs(a[p].c[0],p);
        if(a[p].c[1])
            dfs(a[p].c[1],p);
        mt(p);
    }
    int st[100010];
    void build(int &p,int *e,int l,int r)
    {
        int top=0;
        for(int i=l;i<=r;i++)
        {
            int x=newnode();
            a[x].v=a[x].l=a[x].r=e[i];
            a[x].s=1;
            while(top&&a[x].k>a[st[top]].k)
            {
                a[x].c[0]=st[top];
                mt(st[top]);
                top--;
            }
            if(a[x].c[0])
                a[a[x].c[0]].f=x;
            if(top)
            {
                a[st[top]].c[1]=x;
                a[x].f=st[top];
            }
            st[++top]=x;
        }
        p=st[1];
        while(top)
        {
            if(top>1)
            {
                a[st[top-1]].c[1]=st[top];
                a[st[top]].f=st[top-1];
            }
            mt(st[top]);
            top--;
        }
//      dfs(p,0);
    }
}
namespace sgt
{
    const double alpha=0.75;
    struct node
    {
        int l,r;
        int ls,rs;
        int x;
        int rt;
        int s;
    };
    node a[100010];
    int rt;
    int cnt;
    int *rebuild;
    void mt(int p)
    {
        a[p].s=a[a[p].ls].s+a[a[p].rs].s+1;
        a[p].l=(a[p].ls?a[a[p].ls].l:a[p].x);
        a[p].r=(a[p].rs?a[a[p].rs].r:a[p].x);
    }
    void ins(int &p,int x)
    {
        if(!p)
        {
            p=++cnt;
            a[p].l=a[p].r=x;
            a[p].ls=a[p].rs=0;
            a[p].x=x;
            a[p].rt=0;
            a[p].s=1;
            treap::insert(a[p].rt,::a[x]);
            return;
        }
        treap::insert(a[p].rt,::a[x]);
        if(cmp(x,a[p].x)==1)
        {
            ins(a[p].ls,x);
            mt(p);
            if(a[a[p].ls].s>a[p].s*alpha)
                rebuild=&p;
        }
        else
        {
            ins(a[p].rs,x);
            mt(p);
            if(a[a[p].rs].s>a[p].s*alpha)
                rebuild=&p;
        }
    }
    int tot;
    int c[100010];
    int d[100010];
    void dfs(int &x)
    {
        if(a[x].ls)
            dfs(a[x].ls);
        c[++tot]=x;
        d[tot]=a[x].x;
        if(a[x].rs)
            dfs(a[x].rs);
        treap::del(a[x].rt);
        x=0;
    }
    int e[100010];
    int f[100010];
    void build(int &p,int l,int r)
    {
        if(l>r)
            return;
        int mid=(l+r)>>1;
        p=c[mid];
        a[p].x=d[mid];
//      for(int i=l;i<=r;i++)
//          treap::insert(a[p].rt,::a[d[i]]);
        build(a[p].ls,l,mid-1);
        build(a[p].rs,mid+1,r);
        if(l==r)
            e[l]=::a[d[l]];
        else
        {
            int v=::a[d[mid]];
            int i;
            for(i=mid;i>l&&v<e[i-1];i--)
                e[i]=e[i-1];
            e[i]=v;
            int l1=l,r1=mid+1;
            int t1=l;
            while(l1<=mid||r1<=r)
                if(r1>r||(l1<=mid&&e[l1]<=e[r1]))
                    f[t1++]=e[l1++];
                else
                    f[t1++]=e[r1++];
            for(int i=l;i<=r;i++)
                e[i]=f[i];
        }
        treap::build(a[p].rt,e,l,r);
        mt(p);
    }
    void insert(int x)
    {
        rebuild=0;
        ins(rt,x);
        if(rebuild)
        {
            tot=0;
            dfs(*rebuild);
            build(*rebuild,1,tot);
        }
    }
    int query(int p,int x,int l,int r)
    {
        if(!p)
            return 0;
        if(lcp(a[p].x,x)>=l)
        {
            if(lcp(a[p].l,x)>=l&&lcp(a[p].r,x)>=l)
                return treap::query(a[p].rt,r);
            return query(a[p].ls,x,l,r)+query(a[p].rs,x,l,r)+(::a[a[p].x]<=r?1:0);
        }
        int v=cmp(x,a[p].x);
        int s=0;
        if(v!=-1)
            s+=query(a[p].ls,x,l,r);
        if(v!=1)
            s+=query(a[p].rs,x,l,r);
        return s;
    }
}
void add(int x,int y,int v)
{
    h[x][0]=v;
    f[x][0]=y;
    d[x]=d[y]+1;
    for(int i=1;i<=16;i++)
    {
        f[x][i]=f[f[x][i-1]][i-1];
        h[x][i]=h[x][i-1]*pw[i-1]+h[f[x][i-1]][i-1];
    }
    sgt::insert(x);
}
int query(int x,int l,int r)
{
    return sgt::query(sgt::rt,x,l,r);
}
int main()
{
    open("b");
    srand(time(0));
    mempool::init();
    pw[0]=base;
    for(int i=1;i<=17;i++)
        pw[i]=pw[i-1]*pw[i-1];
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    d[1]=0;
    d[0]=-1;
    char c[2];
    int x,y,l,r;
    for(int i=2;i<=n;i++)
    {
        scanf("%d%d%s",&x,&y,c);
        add(y,x,id(c[0]));
    }
    int last=1;
    for(int i=1;i<=m;i++)
    {
        scanf("%d",&x);
        if(!x)
        {
            scanf("%d%d%d",&x,&l,&r);
            x^=last;
            int ans=query(x,l,r);
            if(!l&&a[1]<=r)
                ans++;
            printf("%d\n",ans);
            if(ans)
                last=ans;
        }
        else
        {
            n++;
            scanf("%d%d%s",&x,&a[n],c);
            x^=last;
            add(n,x,id(c[0]));
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/ywwyww/p/8573561.html

weixin_30572613
关注
[XSY] 绿色（圆方树、树形DP、树上差分）
Edward The Bunny 的博客
03-29 194
绿色 题意简述 题解 首先，每次修改完点权后，重新考虑一遍所有路径显然是不现实的，所以我们考虑求出经过每个点的两端同色的简单路径数，这样权值和容易统计和修改。 接下来分析仙人掌上的简单路径性质。一条简单路径上的边，可以分为桥边和环上的边。过桥只有一种方法，而过同一个环有两个方向的环边可选。 现在，我们选取一个关键点，强制简单路径必须通过该点。如果关键点在一个环上，且该简单路径在该环上的第一个和最后一个点均不是关键点，那么该环只有一个方向的环边可选。 建立原仙人掌的圆方树。 如果定义方点贡献 2 种方案，
【XSY2505】tree（树的直径）（缩点）（数学）
ezoi_ly的博客
09-09 184
Description 机房断网了！xj轻而易举地撬开了中心机房的锁，拉着zwl走了进去。他们发现中心主机爆炸了。 中心主机爆炸后分裂成了 n 块碎片，但碎片仍然互相连接，形成一个树的结构。每个碎片有一个状态值0或1 。zwl找了一下规律，发现只有所有碎片的状态值相同的时候，主机才能够修复。 xj碰了碰其中一个碎片 x ，发现对于满足 x 到 v 的路径上所有碎片的状态值与 x 的状态值相同 的那...
【XSY1537】五颜六色的幻想乡（矩阵树定理+高斯消元+拉格朗日插值）
一个蒟蒻的博客
09-15 367
题意：有nnn个点，mmm条有颜色的边，颜色为红色蓝色和绿色，对于所有满足r+b+g=n−1r+b+g=n−1r+b+g=n-1的三元组(r,b,g)(r,b,g)(r,b,g)，求恰有rrr条红色的边，bbb条蓝色的边，ggg条绿色的边的生成树个数。 题解： 生成树计数基本上就是矩阵树定理啦。 我们可以给每一种颜色赋一个额外的值（在矩阵树定理的时候邻接矩阵和度数矩阵就加这个值），在这里我们...
【XSY2505】tree
09-11 111
\(Description\) 机房断网了！\(xj\)轻而易举地撬开了中心机房的锁，拉着\(zwl\)走了进去。他们发现中心主机爆炸了。 中心主机爆炸后分裂成了\(n\)块碎片，但碎片仍然互相连接，形成一个树的结构。每个碎片有一个状态值\(0\)或\(1\) 。\(zwl\)找了一下规律，发现只有所有碎片的状态值相同的时候，主机才能够修复。 \(xj\)碰了碰其中一个碎片 \(x\) ...
【xsy1237】 字符转换 矩阵快速幂
diaoyoutun2652的博客
02-18 143
题目大意：给你两个长度都为n，字符集为{a,b,c}的字符串S和T。 对于字符串S的任意一个字符，我们可以用cost[0]的代价，把字符a变成字符b。用cost[1]的代价，把字符b变成c，用cost[2]的代价，把字符c变成a。 问你在总代价不超过MaxCost的情况下，有多少种方法，使得字符串S与字符串T相同。 两种方法被认为是不同的，当且仅当操作序列的长度是不同的，或者某一步...
【XSY3345】生成树 并查集
weixin_30722589的博客
12-29 183
题目大意 　　有一个两部各有 \(n\) 个节点的二分图 \(G\)，定义 \(G^m\) 为一个 \(m+1\) 层的图，每层有 \(n\) 个节点，相邻两层的诱导子图都和 \(G\) 相同。 　　给你 \(m\)，求对于所有 \(1\leq i\leq m\)，\(G^i\) 的最小生成树的边权和。 　　保证图连通。 　　\(n,m\leq 100000,\text{边数 }\leq 2000...
【xsy2479】counting 生成函数+多项式快速幂
diaoyoutun2652的博客
04-17 182
题目大意：在字符集大小为$m$的情况下，有多少种构造长度为$n$的字符串$s$的方案，使得$C(s)=k$。其中$C(s)$表示字符串$s$中出现次数最多的字符的出现次数。 对$998244353$取模，$n,m≤5\times 10^4$ 如果你考虑去DP，你就lose了。 令$F(x)$表示满足$C(s)≤x$的方案数。 那么最终的答案显然为$F(k)-F(k-1)$。...
[XSY]Tree Ext（矩阵树定理,拉格朗日插值,最小生成树,二分）
Edward The Bunny 的博客
07-21 172
Tree Ext 这道题相当于把3道题合了起来。 要求修复的边中恰好有 k 条白边： 五颜六色的幻想乡(附拉格朗日插值法求多项式系数 ) + bzoj2654 tree(WQS二分 新科技get) 是最小生成树计数而非生成树计数： BZOJ1016」[JSOI2008] 最小生成树计数 具体可以看看这篇博客，代码中的注释也解释得较清楚 #include<bits/stdc++.h> #define int long long using namespace std; const int mod=
[XSY] PQ树（区间DP）
Edward The Bunny 的博客
03-09 460
PQ树 对于非叶子节点，它只能调换它的儿子的顺序，却不能调换整颗子树的顺序 合法的PQ树都能表示出1,2,3,…,n 这个排列 有以上两点可以得出：PQ树的每棵子树对应的一定都是一段连续的数字区间 考虑区间DP，设f(l,r)f(l,r)f(l,r)表示数字l~r构成一棵PQ树的方案数 数字l~r 能够构成一棵子树 当且仅当 数字l~r 在题目给出的所有排列中都在一段连续区间中，我们定义这样的 [l,r] 是“好的” 若[l,r]不是"好的"，f(l,r)=0f(l,r)=0f(l,r)=0 若[l,r]
[XSY] 树与图（树形DP、生成函数、分治NTT、重链剖分）
Edward The Bunny 的博客
03-17 235
树与图 如果真的在图上跑算法，那么光建图复杂度就O(n2logn)O(n^2logn)O(n2logn)了，这显然不可行。所以一定要把 在图上的操作 转换成 在树上的操作 在图上删去点u，相当于在树上删去u到根节点的链，并把u的整棵子树删掉 如果我们枚举算法可能产生的所有过程，然后再去求每个过程对应的删点次数，那么光枚举过程就已经可以T爆了 所以我们只能枚举删点次数，然后求出该删掉次数对应多少种过程 这可以用树形DP实现，时间复杂度O(n3)O(n^3)O(n3) 可以想到用生成函数进一步优化
【XSY2528】道路建设 LCT 可持久化线段树
ez_yww的博客
10-05 481
题目描述　　给你一个nn个点mm条边图，qq个询问，每次问你边权在[l,r][l,r]之间的边组成的最小生成树（森林）的边权和。强制在线。　　n,m,q≤100000n,m,q\leq 100000题解　　考虑离线做法。从大到小加边，用LCT维护当前的最小生成树。维护一棵线段树，第ii个位置表示当前的最小生成树中边权为ii的边的权值和。当一条边被加入时就在对应位置加上边权，删掉时就减掉边权。假设已经
【xsy1144】选物品 主席树
diaoyoutun2652的博客
02-18 140
题目大意：$N$ 件物品摆成一排，给每个物品定义两个属性 $A$ 和$ B$，两件物品的 差异度 定义为它们两种属性的差的绝对值中较大的一个。如果要求出一些物品的差异度，我们先定义一个 理想物品，使它与这些物品中每个物品的差异度的和最小，这些物品的差异度就是这个最小的和。给定$ N$ 个物品和Q组询问，询问从 $L $到 $R$ 的物品差异度为多少。 我们设物品$i$和物品$j$之间的...
【xsy1230】 树(tree) 点分治+线段树
diaoyoutun2652的博客
02-18 156
题目大意：有一棵$n$个节点的树，点的标号为$1$到$n$。树中的边有边权。给你$m$个询问，每个询问包含三个参数$l,r,pos$,你要求出标号在$l$到$r$之间的所有点中，到节点$pos$距离最近的点离$pos$有多远。 数据范围：$n,m,l,r,pos≤10^5$，强制在线。 此题我强制在线两个变量打反了，$wa$了一发。 我们考虑点分治，对于节点x，我们在节点$x...
XSY 1749 tree
dk810510的博客
09-13 135
题目大意 给定一棵基环树, 问你有多少条路径的长度\(\ge K\). 点数\(\le 10^5\) Solution 基环树分治模板题. 我是这样做的: 加边的时候用并查集维护点的连通性, 少加入环上的一条边, 使得基环图变为树的形态. 首先在树上进行一次常规的树分治. 我们能得到不经过被删除的一条边的满足要求的路径数量; 然后我们根据被删去的边的两个端点找到环, 在环上求出经过被删去...
【XSY3163】Tree Ext【二分】【最小生成树】【矩阵树定理】【拉格朗日插值】
2016gdgzoi471
08-14 798
给一张 n 个点 m 条边的无向连通图，每条边是黑边或白边 ，有边权。问有多少棵恰好有k条白边，且在此前提下边权和最小的生成树。mod 1e9+7。 首先看一看这道题。 ACM Live Archieve 7138 这里有一个无比良心的题解。 这里写链接内容 膜拜这位不知名的ACM大神！ 由于发现博主已经两年多没更新了，这个网站可能会隔，蒟蒻截了张图。。。如果侵权，马上删除。 对...
【xsy1303】生成树 乱搞
diaoyoutun2652的博客
04-03 122
题目大意：给你n个点，问这n个点构成的最小标准差生成树的值 这题题解里面写的都是什么代码？？ 你用O(n^4)的复杂度，枚举出两条边，然后求平均数。 对于剩下的边，我们求出这些边与平均数的差，然后求最下差生成树。 然后就过了？？？ 不是很懂 1 #include<bits/stdc++.h> 2 #define M 22 3 #define s...
SVM支持向量机
最新发布
weixin_51658186的博客
10-08 418
向量机可解决分类和回归两种问题，监督学习方法。SVM起初针对二分类问题提出，1、2、3小节都是针对二分类问题展开理论推导，y取±1！
Leetcode 打家劫舍
985小菜鸡
10-08 305
设dp[i]表示前i个房屋能偷取的最大金额。不偷当前房屋 i：那么最大金额是dp[i-1]，即上一个房屋的最大偷取金额。偷当前房屋 i：那么最大金额是，即偷取当前房屋 i，加上不相邻的房屋（即房屋i-2）的最大金额。其中dp[i-1]是不偷当前房屋，是偷当前房屋。
线性结构（四）栈及其代码实现及OJ题
m0_74328241的博客
10-07 954
栈也是很重要的一种线性数据结构，注意与操作系统中的栈进行区分，以及合理选择其物理结构。
http://localhost/api/xsy-auth-security/loginUser/login 403 (Forbidden)
07-28
- *2* [c/c++使用libcurl库做http客户端及封装(HTTP_GET和HTTP_POST)](https://blog.csdn.net/xsy29000/article/details/103181267)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值