void bvh_done<SVBVHTree>(SVBVHTree *obj)
{
rtbuild_done(obj->builder, &obj->rayobj.control);
//TODO find a away to exactly calculate the needed memory
MemArena *arena1 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE);
BLI_memarena_use_malloc(arena1);
MemArena *arena2 = BLI_memarena_new(BLI_MEMARENA_STD_BUFSIZE);
BLI_memarena_use_malloc(arena2);
BLI_memarena_use_align(arena2, 16);
//Build and optimize the tree
if(0)
{
VBVHNode *root = BuildBinaryVBVH<VBVHNode>(arena1,&obj->rayobj.control).transform(obj->builder);
if(RE_rayobjectcontrol_test_break(&obj->rayobj.control))
{
BLI_memarena_free(arena1);
BLI_memarena_free(arena2);
return;
}
reorganize(root);
remove_useless(root, &root);
bvh_refit(root);
pushup(root);
pushdown(root);
pushup_simd<VBVHNode,4>(root);
obj->root = Reorganize_SVBVH<VBVHNode>(arena2).transform(root);
}
else
{
//Finds the optimal packing of this tree using a given cost model
//TODO this uses quite a lot of memory, find ways to reduce memory usage during building
OVBVHNode *root = BuildBinaryVBVH<OVBVHNode>(arena1,&obj->rayobj.control).transform(obj->builder);
if(RE_rayobjectcontrol_test_break(&obj->rayobj.control))
{
BLI_memarena_free(arena1);
BLI_memarena_free(arena2);
return;
}
VBVH_optimalPackSIMD<OVBVHNode,PackCost>(PackCost()).transform(root);
obj->root = Reorganize_SVBVH<OVBVHNode>(arena2).transform(root);
}
//Free data
BLI_memarena_free(arena1);
obj->node_arena = arena2;
obj->cost = 1.0;
rtbuild_free( obj->builder );
obj->builder = NULL;
}
inline void splay() {
while(!isroot()) {
if(!fa->isroot()) {
if(fa->dir() == dir()) fa->rot();
else rot();
}
rot();
}
pushup();
}
void build(father) {
if(l == r) {
scanf("%d",sum+rt);
return ;
}
calm ;
build(lson);
build(rson);
pushup(rt);
}
void rotate(int u)
{
int f = fa[u];
int p = son[f][0] == u;
son[f][!p] = son[u][p];
if(son[u][p]) fa[son[u][p]] = f;
if(not_root(f)) son[fa[f]][son[fa[f]][1] == f] = u;
fa[u] = fa[f];
son[fa[f] = u][p] = f;
pushup(f);
}
void build (int l, int r, int root) {
if (l == r) {
scanf("%d%d%d", &sum[root], &m[l], &ri[l]);
t[l] = 0;
return;
}
int mid = (l+r)>>1;
build(l,mid, root<<1);
build(mid+1, r, root<<1|1);
pushup(root);
}
void splay(int u)
{
for(clear_mark(u); not_root(u); rotate(u))
{
int f = fa[u];
if(not_root(f))
rotate(((son[f][0] == u) ^ (son[fa[f]][0] == f)) ? u : f);
}
pushup(u);
}
//单点更新
void update(int i, int x, int val)
{
if (tree[i].l == x && tree[i].r == x)
{
tree[i].sum = val;
return;
}
if (x <= tree[L(i)].r) update(L(i), x, val);
else update(R(i), x, val);
pushup(i);
}
inline void erase(int x) {//把以x为祖先结点删掉放进内存池,回收内存
int father = pre[x];
int head = 0 , tail = 0;
for (que[tail++] = x ; head < tail ; head ++) {
ss[top2 ++] = que[head];
if(ch[ que[head] ][0]) que[tail++] = ch[ que[head] ][0];
if(ch[ que[head] ][1]) que[tail++] = ch[ que[head] ][1];
}
ch[ father ][ ch[father][1] == x ] = 0;
pushup(father);
}
void clea(int time, int L, int R, int l, int r, int root) {
if(l==r&&(l>=L && l<=R)){
t[l] = time;
sum[root] = 0;
return;
}
int mid = (l+r)>>1;
if(L<=mid) clea(time, L, R, l, mid, root<<1);
if(mid<R) clea(time, L, R, mid+1, r, root<<1|1);
pushup(root);
}
void build(int l,int r,int rt) {
int mid;
if (l==r) {
scanf("%d",ans1+rt);
ans2[rt]=ans1[rt];
return ;
}
mid=(l+r)>>1;
build(Lson);
build(Rson);
pushup(rt);
}
// read input and build segment tree //
void build(int l, int r, int root)
{
if (l == r)
{
scanf("%d", &node[root]);
return ;
}
int mid = (l+r) >> 1;
build(lson);
build(rson);
pushup(root);
}
void build(int l,int r,int n)
{
if(l==r)
{
scanf("%d",&sum[n]);
return;
}
int m=(l+r)>>1;
build(lson);
build(rson);
pushup(n);
}
void recover(int time, int L, int R, int l, int r, int root) {
if (l==r &&(l>=L && l<=R)) {
int tmp = (time - t[l])*ri[l];
if(sum[root] + tmp > m[l]) sum[root] = m[l];
else sum[root]+=tmp;
return ;
}
int mid = (l+r)>>1;
if(L<=mid) recover(time, L, R, l, mid, root<<1);
if(mid<R) recover(time, L, R, mid+1, r, root<<1|1);
pushup(root);
}
void add(int pos,int val, father) {
if(l == r) {
sum[rt] += val;
return ;
}
calm ;
if(pos <= m)
add(pos,val,lson);
else
add(pos,val,rson);
pushup(rt);
}
void update(int l,int r,int num,lrrt) {
if(l <= L && R <= r) {
tree[rt].sum += (R-L+1) * num;
tree[rt].lazy += num;
return;
}
imid;
pushdown(mid,L,R,rt);
if(mid >= l) update(l,r,num,lson);
if(mid < r) update(l,r,num,rson);
pushup(rt);
}
void build(lrrt) {
tree[rt].lazy = 0;
if(L == R) {
LL temp;
scanf("%I64d",&temp);
tree[rt].sum = temp;
return;
}
imid;
build(lson);
build(rson);
pushup(rt);
}
void build(int rt, int l, int r) {
int mid = (l + r) >> 1;
node[rt].lazy = 0;
node[rt].degree = 0;
if (l == r) {
node[rt].x = val[l].x;
node[rt].y = val[l].y;
}
else {
build(lson); build(rson);
pushup(rt, l, r);
}
}
void splay(int u)
{
if(!u) return;
for(; not_root(u); rotate(u))
{
int f = fa[u];
if(not_root(f))
rotate(((son[f][0] == u) ^ (son[fa[f]][0] == f)) ? u : f);
}
pushup(u);
root = u;
}
void rotate(int u)
{
int f = fa[u];
bool p = son[f][0] == u;
fa[u] = fa[f];
if(not_root(f))
son[fa[f]][son[fa[f]][0] != f] = u;
if(!!(son[f][!p] = son[u][p]))
fa[son[u][p]] = f;
fa[son[u][p] = f] = u;
pushup(f);
}
void build(int l,int r,int x)
{
lz[x] = 0;
if(l == r) {
sum[x] = (s[l] == '1');
A[x] = sum[x]; B[x] = !A[x];
return ;
}
int m = l + r >> 1;
build(l,m,x+x);
build(m+1,r,x+x+1);
pushup(x,l,r);
}
void insert(int L,int R,int l,int r,int x)
{
if(L <= l && r <= R) {
flip(x,l,r);
lz[x] ^= 1;
return ;
}
push(x,l,r);
int m = l + r >> 1;
if(L <= m) insert(L,R,l,m,x+x);
if(R > m) insert(L,R,m+1,r,x+x+1);
pushup(x,l,r);
}
void put(int L,int R, father) {
if(l >= L && r <= R) {
sum[rt] = r-l+1;
lazy[rt] = 1;
return ;
}
calm ;
if(m >= L)
put(L,R,lson);
if(m+1 <= R)
put(L,R,rson);
pushup(rt);
}
void update(int rt, int l, int r, int ql, int qr, int Val) {
if (ql <= l && qr >= r) {
node[rt].lazy += Val;
Rotate(node[rt], Val);
}
else {
int mid = (l + r) >> 1;
pushdown(rt, l, r);
if (ql <= mid) update(lson, ql, qr, Val);
if (qr > mid) update(rson, ql, qr, Val);
pushup(rt, l, r);
}
}
void build(int i, int left, int right)
{
tree[i].l = left; tree[i].r = right;
if (left == right)
{
tree[i].max = tree[i].sum = val[pos[left]];
return;
}
int mid = left + (right - left >> 1);
build(L(i), left, mid);
build(R(i), mid + 1, right);
pushup(i);
}
void update(int i,int x,int l,int r)
{
if(l==r)
{
int rt=IDX(l,r);
tree[rt]+=x;
return;
}
int mid=l+r>>1;
pushdown(l,r);
if(i<=mid) update(i,x,l,mid);
else update(i,x,mid+1,r);
pushup(l,r);
}
void update(int i, int left, int right, int key)
{
if (left <= tree[i].l && right >= tree[i].r)
{
tree[i].sum += (tree[i].r - tree[i].l + 1) * key;
tree[i].max += key;
tree[i].lazy += key;
return;
}
pushdown(i);
if (left <= tree[L(i)].r) update(L(i), left, right, key);
if (right >= tree[R(i)].l) update(R(i), left, right, key);
pushup(i);
}
void updata( int k, int c, int l, int r, int rt )
{
if ( l==r )
{
seg[rt] += c;
return ;
}// destination
int mid = ( l+r )>>1;
if ( k<=mid ) updata( k, c, l, mid, rt<<1 );
else updata( k, c, mid+1, r, rt<<1|1 );
pushup( rt );
}// updata
void BuildTree( int l, int r, int rt )
{
seg[rt] = 0;
if ( l==r )
{
scanf("%d", &seg[rt]);
return ;
}// destination
int mid = ( l+r )>>1;
BuildTree( l, mid, rt<<1 );
BuildTree( mid+1, r, rt<<1|1 );
pushup( rt );
}// BuildTree
void update(int L,int R,int w,int l,int r)
{
if(L<=l && R>=r)
{
int rt=IDX(l,r);
tree[rt]+=(r-l+1)*w;
lzy[rt]+=w;
return;
}
int mid=l+r>>1;
pushdown(l,r);
if(L<=mid) update(L,R,w,l,mid);
if(R>mid) update(L,R,w,mid+1,r);
pushup(l,r);
}
void build(int L,int R,int u)
{
p[u].add = 0;
if(L == R)
{
p[u].Max = p[u].Min = A[L];
}
else
{
int m = (L+R)/2;
build(L,m,u<<1);
build(m+1,R,u<<1|1);
pushup(u);
}
}
