【BZOJ2658】小蓝的好友(ZJOI2012)-扫描线+Treap

本文介绍了一种结合Treap(一种自平衡二叉搜索树)与扫描线算法解决复杂几何问题的方法。通过构建Treap来高效处理动态区间更新与查询,实现O(nlogn)的时间复杂度。

测试地址:小蓝的好友
做法:本题需要用到扫描线+Treap。
首先,很快想到补集转化,用总的子矩形数( n(n+1)2m(m+1)2 n ( n + 1 ) 2 ⋅ m ( m + 1 ) 2 )减去不包含任何资源点的子矩形数计算答案。
考虑自上而下用扫描线,每次计算下边界在某一行的,不包含任何资源点的子矩形数目。考虑上边界所在的行,这一行能选为上边界的区间数目与这一行与下面的行的资源点有关,每个资源点会将上面的每一行的某些区间划分成两个部分。于是想到维护每一列最低的资源点位置,然后每个点向分裂成的两个新区间内的最低点连边,形成一棵二叉树。我们发现,在这棵二叉树中,DFS序就是列的顺序,而父亲的高度总比儿子的高度要低,这就是一棵Treap(好像又称笛卡尔树)了。
考虑有了这棵Treap,如何计算可以作为上边界的区间数目。因为DFS序就是列的顺序,所以一棵子树就表示一个区间,而子树的根是高度最低的资源点,以它父亲为根的子树是一个新的区间,我们发现这棵子树的根可以代表一个小矩形,表示父亲分裂的行开始向上,到这个根分裂之前的行,这棵子树所代表的整个区间的所有列组成的小矩形,显然这个小矩形内任意一个区间都可以作为上界。而这样我们就可以根据整个Treap每个点的高度,子树大小等信息,不重复地统计出当前行的答案了。
接下来考虑新的一行,首先所有点的高度都 +1 + 1 ,因为我们计算信息时实际上用的是高度的差,于是我们开一个空点作为整棵Treap根的父亲,当进行这个操作时,只要将空点的高度
1 − 1 即可。然后是新增一个资源点,实际上就是把某一列的高度弄到和空点的高度相同,只需一路转上去,顺便维护信息即可。注意修改一个点时,这个点以及它儿子的信息都会改变。因为资源点的位置随机,所以Treap的平均深度是 O(logn) O ( log ⁡ n ) 的,所以总的时间复杂度为 O(nlogn) O ( n log ⁡ n ) ,可以通过此题。
以下是本人代码:

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,ch[40010][2]={0},pre[40010];
ll r,c,h[40010]={0},ans,tot,siz[40010]={0};
struct point
{
    ll x,y;
}p[100010];

bool cmp(point a,point b)
{
    return a.x<b.x;
}

void buildtree(int l,int r,int fa,int type)
{
    if (l>r) return;
    int mid=(l+r)>>1;
    pre[mid]=fa;
    ch[fa][type]=mid;
    if (l==r) {siz[mid]=1;return;}
    buildtree(l,mid-1,mid,0);
    buildtree(mid+1,r,mid,1);
    siz[mid]=siz[ch[mid][0]]+siz[ch[mid][1]]+1;
}

void update(int v,ll type)
{
    tot+=type*siz[v]*(siz[v]+1ll)/2ll*(h[v]-h[pre[v]]);
}

void modify(int x,ll newh)
{
    update(x,-1ll);
    if (ch[x][0]) update(ch[x][0],-1ll);
    if (ch[x][1]) update(ch[x][1],-1ll);
    h[x]=newh;
    update(x,1ll);
    if (ch[x][0]) update(ch[x][0],1ll);
    if (ch[x][1]) update(ch[x][1],1ll);

    while(pre[x])
    {
        int y=pre[x];
        bool f=(ch[y][0]==x);
        if (ch[x][f]) update(ch[x][f],-1ll);
        update(x,-1ll);
        update(y,-1ll);

        ch[y][!f]=ch[x][f];
        pre[ch[x][f]]=y;
        ch[x][f]=y;
        ch[pre[y]][ch[pre[y]][1]==y]=x;
        pre[x]=pre[y];
        pre[y]=x;

        siz[y]=siz[ch[y][0]]+siz[ch[y][1]]+1;
        siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+1;
        if (ch[y][!f]) update(ch[y][!f],1ll);
        update(x,1ll);
        update(y,1ll);
    }
}

int main()
{
    scanf("%lld%lld%d",&r,&c,&n);
    for(int i=1;i<=n;i++)
        scanf("%lld%lld",&p[i].x,&p[i].y);
    sort(p+1,p+n+1,cmp);

    buildtree(1,c,0,1);
    ans=0,tot=0;
    int now=1;
    for(int i=1;i<=r;i++)
    {
        if (ch[0][0]) update(ch[0][0],-1ll);
        if (ch[0][1]) update(ch[0][1],-1ll);
        h[0]--;
        if (ch[0][0]) update(ch[0][0],1ll);
        if (ch[0][1]) update(ch[0][1],1ll);

        while(now<=n&&p[now].x==i)
        {
            modify(p[now].y,h[0]);
            now++;
        }
        ans+=tot;
    }
    printf("%lld",r*(r+1ll)/2ll*c*(c+1ll)/2ll-ans);

    return 0;
}
Treap(Tree + Heap)是一种结合了二叉搜索树(BST)和堆(Heap)特性的平衡二叉搜索树数据结构。其核心原理在于每个节点维护两个值:一个用于二叉搜索树性质的键值(key),以及一个用于最大堆性质的优先级(priority)。通过这两个属性,Treap在插入和删除操作时保持树的平衡性,从而确保操作的时间复杂度接近于对数级别。 ### Treap的基本原理 1. **二叉搜索树性质**:对于任意节点,其左子树中所有节点的键值小于当前节点的键值,右子树中所有节点的键值大于当前节点的键值。 2. **堆性质**:每个节点的优先级大于其子节点的优先级,这样可以确保树的结构在插入或删除时通过旋转操作保持平衡。 在插入新节点时,Treap首先按照二叉搜索树的方式找到合适的位置,并赋予该节点一个随机的优先级。如果该节点的优先级违反了堆性质,则通过旋转操作调整树的结构以恢复堆性质。删除操作类似,通过旋转确保堆性质得以维持。 ### 无旋Treap的实现 无旋Treap(Non-Rotating Treap)是Treap的一个变种,它通过分裂(Split)和合并(Merge)操作来实现树的平衡,而不是传统的旋转操作。分裂操作将树按照某个键值或位置分割为两部分,而合并操作将两个树合并为一个。这种方式简化了实现逻辑,尤其是在处理复杂操作时[^2]。 例如,分裂操作可以通过以下方式实现(以键值为分割点): ```python def split(node, key): if node is None: return (None, None) if node.key <= key: left, right = split(node.right, key) node.right = left return (node, right) else: left, right = split(node.left, key) node.left = right return (left, node) ``` 合并操作则需要确保堆性质的维护: ```python def merge(left, right): if left is None: return right if right is None: return left if left.priority > right.priority: left.right = merge(left.right, right) return left else: right.left = merge(left, right.left) return right ``` ### 应用场景 Treap由于其高效的平衡特性,广泛应用于需要高效查找、插入和删除操作的场景。常见的应用包括: - **数据库索引**:Treap可以用于实现高效的索引结构,支持快速的数据检索。 - **内存中的集合与映射**:在需要频繁插入和删除元素的场景中,Treap提供了良好的性能保障。 - **算法竞赛**:在某些需要高效数据结构的竞赛题中,Treap常被用来实现动态集合操作[^1]。 ### 实现细节 在实现Treap时,需要注意以下几点: - **随机优先级生成**:为了保证树的平衡性,每个节点的优先级应随机生成,通常使用大范围的整数以减少冲突的可能性。 - **递归与非递归实现**:虽然递归实现较为直观,但在大规模数据处理时可能会导致栈溢出,因此在实际应用中可以考虑非递归实现。 - **类型安全与内存管理**:特别是在使用Rust等语言时,需注意类型约束和内存安全,以确保程序的稳定性和可靠性[^1]。 通过理解Treap的原理和实现方式,开发者可以更好地将其应用于实际项目中,并根据需求进行扩展和优化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值