BZOJ - 3224 可持久化Treap 树形操作

本文介绍了一种高效的数据结构——Treap树堆,并通过一个具体的实现案例展示了其基本操作,包括插入、删除、查找等。Treap结合了二叉搜索树和堆的特点,能够有效地进行动态集合的操作。

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

这个题目去年就做过了,这次稍微改了一下
都是基础操作

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#define rep(i,j,k) for(register int i=j;i<=k;i++)
#define rrep(i,j,k) for(register int i=j;i>=k;i--)
#define erep(i,u) for(register int i=head[u];~i;i=nxt[i])
#define iin(a) scanf("%d",&a)
#define lin(a) scanf("%lld",&a)
#define din(a) scanf("%lf",&a)
#define s0(a) scanf("%s",a)
#define s1(a) scanf("%s",a+1)
#define print(a) printf("%lld",(ll)a)
#define enter putchar('\n')
#define blank putchar(' ')
#define println(a) printf("%lld\n",(ll)a)
#define IOS ios::sync_with_stdio(0)
using namespace std;
const int MAXN = 2e5+11;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-7;
typedef long long ll;
const ll MOD = 1e9+7; 
unsigned int SEED = 19260817;
ll read(){
    ll x=0,f=1;register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline int Rand(){
    SEED=SEED*1103515245+12345;
    return SEED/65536;
}
struct Treap{
    int son[MAXN][2],root,tot;
    int val[MAXN],fix[MAXN],size[MAXN];
    #define lc son[o][0]
    #define rc son[o][1]
    void init(){
        root=0;
        son[0][0]=son[0][1]=0;
        val[0]=fix[0]=size[0]=0;
        tot=1;
    }
    int node(int v){
        son[tot][0]=son[tot][1]=0;
        val[tot]=v; fix[tot]=Rand();
        size[tot]=1;
        return tot++;
    }
    void pu(int o){
        size[o]=size[lc]+size[rc]+1;
    }
    void split(int o,int pivot,int &a,int &b){
        if(!o){
            a=b=0;
            return;
        }else if(val[o]>pivot){
            b=o;
            split(lc,pivot,a,lc);
            pu(o);
        }else{
            a=o;
            split(rc,pivot,rc,b);
            pu(o);
        }
    }
    int merge(int a,int b){
        if(!a) return b;
        if(!b) return a;
        if(fix[a]<fix[b]){
            son[a][1]=merge(son[a][1],b);
            pu(a);
            return a;
        }else{
            son[b][0]=merge(a,son[b][0]);
            pu(b);
            return b;
        }
    }
    void insert(int v){
        int a,b,t=node(v);
        split(root,v,a,b);
        root=merge(merge(a,t),b);
    }
    void del(int x){
        int a,b,c,d;
        split(root,x,a,b);
        split(a,x-1,c,d);
        d=merge(son[d][0],son[d][1]);//d的根不要了
        root=merge(merge(c,d),b);
    }
    int krank(int k){
        int a,b;
        split(root,k-1,a,b);
        int res=size[a]+1; //最小的相同数必然是恰比k-1子树规模大 
        root=merge(a,b);
        return res;
    }
    int kth(int k){
        int o=root;
        while(1){
            if(k<=size[lc]){
                o=lc;
            }else if(k==size[lc]+1){
                return o;
            }else{
                k-=size[lc]+1;
                o=rc;
            }
        } 
    }
    int kth(int o,int k){
        while(1){
            if(k<=size[lc]){
                o=lc;
            }else if(k==size[lc]+1){
                return o;
            }else{
                k-=size[lc]+1;
                o=rc;
            }
        } 
    }
    int pre(int x){
        int a,b;
        split(root,x-1,a,b);
        int t=kth(a,size[a]);
        root=merge(a,b);
        return t;
    }
    int succ(int x){
        int a,b;
        split(root,x,a,b);
        int t=kth(b,1);
        root=merge(a,b);
        return t;
    }
}tp;
int n,m,a[MAXN];
int main(){
    while(cin>>n){
        tp.init();
        rep(i,1,n){
            int op=read();
            int x=read();
            switch(op){
                case 1:tp.insert(x);break;
                case 2:tp.del(x);break;
                case 3:println(tp.krank(x));break;
                case 4:println(tp.val[tp.kth(x)]);break;
                case 5:println(tp.val[tp.pre(x)]);break;
                case 6:println(tp.val[tp.succ(x)]);break;
            }
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/caturra/p/8803838.html

内容概要:本文详细介绍了利用粒子群优化(PSO)算法解决配电网中分布式光伏系统的选址与定容问题的方法。首先阐述了问题背景,即在复杂的配电网环境中选择合适的光伏安装位置和确定合理的装机容量,以降低网损、减小电压偏差并提高光伏消纳效率。接着展示了具体的PSO算法实现流程,包括粒子初始化、适应度函数构建、粒子位置更新规则以及越界处理机制等关键技术细节。文中还讨论了目标函数的设计思路,将多个相互制约的目标如网损、电压偏差和光伏消纳通过加权方式整合为单一评价标准。此外,作者分享了一些实践经验,例如采用前推回代法进行快速潮流计算,针对特定应用场景调整权重系数,以及引入随机波动模型模拟光伏出力特性。最终实验结果显示,经过优化后的方案能够显著提升系统的整体性能。 适用人群:从事电力系统规划与设计的专业人士,尤其是那些需要处理分布式能源集成问题的研究人员和技术人员。 使用场景及目标:适用于希望深入了解如何运用智能优化算法解决实际工程难题的人士;旨在帮助读者掌握PSO算法的具体应用方法,从而更好地应对配电网中分布式光伏系统的选址定容挑战。 其他说明:文中提供了完整的Matlab源代码片段,便于读者理解和复现研究结果;同时也提到了一些潜在改进方向,鼓励进一步探索和创新。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值