soj 4018upit解题报告 splay经典应用

时隔一年，终于解决了upit。。。

先给个题目连接：soj:upit

题目大意：

维护一段序列，序列有4种操作：

1.将[A,B]的值统一赋值为X

2.将[A,B]的值每一个都添加X的若干倍，方法为第一个+X,之后的+2X,3X,.....,kX，如此递推

3.在第C个数之前插入数值X

4.求区间[A,B]的和。

具体参考如下：



序列初始长度为N，开始给出这N个数，之后又M个操作，其中N,M<=100,000 ，A,B均合法，X<=100（其实在64位范围就行了），结果在64位整型内。

分析：

这道题是个典型的序列维护的问题，且维护为区间块，有插入操作，需要惰性维护。

splay和块状链表都可以完成这种维护操作。

以下splay解：

①：插入，求和自不必说。。

②：将[A,B]整体赋值的操作，显然在维护的节点上加入两个域即可满足要求。这里记为clear（int），clFlag(bool)标记该子树是否被赋值，如果被赋值则为true

将clear赋值为-INF的时候表示未赋值可以省去变量clFlag

③：整体加法操作：

考虑之前有[A,B]+X，其子树记为R

后来因为R的旋转等因素将[A,B]分割成[A,C] + [C+1,B]，这种时候A到C还是每个元素从+X，+2X，...，+kX，而C+1到B的部分则变成了+(k+1)X，....，+(k+m)X了，

也就是+kX+X，....，+kX+mX

其中k为子树[A,C]的节点数，m为[C+1,B]的节点数。

故每个区间由2个域构成，一个是基础的X，一个是附加的kx，分别记为addition和st

④：操作的组合

考虑对区间值进行操作的赋值和整体加法共2种

其组合无非是4种：赋值&赋值，赋值&加法，加法&加法，加法&赋值。

在区间维护的时候（lazy操作），第二次赋值显然要覆盖第一次赋值，先加法后赋值之前的加法也被覆盖

第二次加法累加到第一次加法上即可，还有就是先赋值后加法。

故在维护的时候有四种情况：

1.该节点仅有赋值，则赋值操作。

2.该节点仅有加法，则加法操作。

3.该节点均有，则必然是先赋值后加法，如果是先加法后赋值，则在上次维护的时候加法被赋值覆盖掉，仅剩赋值操作了。

4.均无。

ps:注意lazy操作，update更新sum，size等域的时候，前提是子树的数据sum和size已经是正确的。

在维护函数help的时候，计算保证该节点的sum和size是正确的，由下往上update。

故凡是在向下搜索节点的时候都要help，在伸展操作的时候要update。

注意update的前提，旋转后要先维护在update。

附个代码：

#include <stdio.h>
#include <ctype.h>

const int maxn = 200010;
const int INF = 0x7fffffff;
int root , n , m , k ;
typedef long long ll;
int array[maxn] ;

void help(int);

struct node
{
int l,r,p;
int size,clear;
ll add,st,sum,key;
void init()
{
l = p = r = add = st = sum = key = 0 ;
clear = -INF ;
size = 1 ;
}
} tree[maxn];

inline void update(int x)
{
if(!x) return ;
tree[x].size = tree[tree[x].l].size+tree[tree[x].r].size+1;
tree[x].sum = tree[tree[x].l].sum + tree[tree[x].r].sum + tree[x].key ;
}

inline int get()
{
int t = 0 ;
bool flag = 0 ;
char c;
while(!isdigit(c = getchar())&&c!='-');
if(c=='-') flag = 1;
else t = c - 48;
while(isdigit(c = getchar()))
t = (t << 1) + (t << 3) + c - 48;
return flag?-t:t;
}

inline void rotate(int x,int type)
{
int y = tree[x].p;
if(type)
{
tree[y].l = tree[x].r ;
tree[x].r = y ;
tree[tree[y].l].p = y ;
}
else
{
tree[y].r = tree[x].l ;
tree[x].l = y ;
tree[tree[y].r].p = y ;

}
tree[x].p = tree[y].p ;
tree[y].p = x ;
if( tree[tree[x].p].l == y ) tree[tree[x].p].l = x ;
else tree[tree[x].p].r = x ;
/*上次就是这个，这次还是！！！*/
help(tree[y].l);
help(tree[y].r);
update(y);
update(x);
}

inline void splay(int x,int rr)    //将x旋转到rr的儿子的位置
{
if( x == rr )    return ;
if( rr == 0 ) root = x ;
while(tree[x].p!=rr)
{
int y = tree[x].p ;
int z = tree[y].p ;
if( z == rr )    rotate(x,tree[y].l==x);
else
{
if( tree[z].l == y )
{
if(tree[y].l==x)
{
rotate(y,1);
rotate(x,1);
}
else
{
rotate(x,0);
rotate(x,1);
}
}
else
{
if(tree[y].r==x)
{
rotate(y,0);
rotate(x,0);
}
else
{
rotate(x,1);
rotate(x,0);
}
}
}
}
}

inline void help(int x)
{
if(!x)    return ;
if ( tree[x].clear != -INF )
{
if( tree[x].add == 0 )
{
tree[x].key = tree[x].clear ;
tree[x].sum = (ll)tree[x].size * tree[x].clear ;
tree[tree[x].r].clear = tree[tree[x].l].clear = tree[x].clear;
tree[tree[x].r].add = tree[tree[x].l].add = 0 ;
tree[tree[x].r].st = tree[tree[x].l].st = 0 ;
}
else
{
int xl = tree[x].l ;
int xr = tree[x].r ;
tree[x].key = (ll)tree[x].clear + (ll)( tree[xl].size + 1 )*tree[x].add + tree[x].st ;
tree[x].sum = (ll)(tree[x].clear+tree[x].st)*tree[x].size+(ll)tree[x].size*(tree[x].size+1)/2*tree[x].add;
tree[xl].clear = tree[xr].clear = tree[x].clear;
tree[xl].add = tree[xr].add = tree[x].add ;
tree[xl].st = tree[x].st ;
tree[xr].st = tree[x].st + (ll)(tree[xl].size+1)*tree[xl].add;
}
}
else
{
if( tree[x].add != 0 )
{
int xl = tree[x].l ;
int xr = tree[x].r ;
tree[x].key += (ll)(tree[xl].size+1)*tree[x].add+tree[x].st ;
tree[x].sum += (ll)tree[x].size * tree[x].st + (ll)tree[x].size * (tree[x].size+1) / 2 * tree[x].add ;
tree[xl].add += tree[x].add ;
tree[xl].st += tree[x].st ;
tree[xr].add += tree[x].add ;
tree[xr].st += (ll)(tree[xl].size+1)*tree[x].add + tree[x].st ;
}
}
tree[x].st = tree[x].add = 0 ;
tree[x].clear = -INF ;
}

void insert(int value,int pos);

inline void build(int l,int r)
{
/*k = 3 ;
tree[1].init();
tree[2].init();
tree[1].r = 2 ;
tree[2].p = 1 ;
update(1);
root = 1 ;
int i ;
for( i = n ; i >= 1 ; i--) insert(array[i],1);*/
int temp = k ;
//tree[k].init();
if( l == r )
{
tree[k].sum = tree[k].key = array[l-1] ;
tree[k].l = tree[k].r = 0 ;
tree[k].clear = -INF;
tree[k].add = tree[k].st = 0 ;
tree[k].size = 1 ;
}
else
{
int mid = (l+r)>>1 , j = k ;
tree[k].key = array[mid-1] ;
if(mid==l)    tree[k].l = 0 ;
else
{
tree[j].l = ++k;
tree[k].p = j ;
build(l,mid-1);
}
tree[j].r = ++k;
tree[k].p = j ;
build(mid+1,r);
tree[j].clear = -INF;
tree[j].add = tree[j].st = 0 ;
update(j);
}
}

inline int Rank(int key)    //查找第k个元素
{
int cur = root , j = 0 ;
while(1)
{
help(cur);
if( 1+tree[tree[cur].l].size+j == key )    return cur ;
else if( tree[tree[cur].l].size+j+1 < key )
{
j += (tree[tree[cur].l].size+1) ;
cur = tree[cur].r ;
}
else cur = tree[cur].l ;
}
}

inline ll querySum(int l,int r)
{
int temp = Rank(l);
int rr = Rank(r+2);
splay(temp,0);
splay(rr,temp);
help(temp);
help(rr);
help(tree[rr].l);
help(tree[tree[rr].l].l);
help(tree[tree[rr].l].r);
update(tree[rr].l);

return tree[tree[rr].l].sum ;
}

//在pos前插入数据value
inline void insert(int value,int pos)
{
int posTh = Rank(pos);
splay(posTh,0);
int temp = tree[posTh].r ;
help(temp);
while( tree[temp].l != 0 ) {    temp = tree[temp].l ; help(temp);   }
tree[temp].l = ++k;
int newnode = k ;
tree[newnode].key = value ;
tree[newnode].size = 1 ;
tree[newnode].sum = value ;
tree[newnode].l = tree[newnode].r = 0 ;
tree[newnode].p = temp ;
tree[newnode].clear = -INF;
tree[newnode].add = tree[newnode].st = 0 ;
splay(newnode,0);
}

void clear(int l,int r,int x)
{
int temp = Rank(l);
int tmp = Rank(r+2);
splay(temp,0);
splay(tmp,temp);
tree[tree[tmp].l].clear = x ;
tree[tree[tmp].l].add = 0 ;
}

void addInterval(int l,int r,int x)
{
int temp = Rank(l);
int tmp = Rank(r+2);
splay(temp,0);
splay(tmp,temp);
int interval = tree[tmp].l ;
tree[interval].add += x ;
}

inline void work()
{
int l , r , x , y , op ;
while(m--)
{
op = get();
if( op == 1 )
{
l = get();
r = get();
x = get();
clear(l,r,x);
}
else if( op == 4 )
{
l = get();
r = get();
printf("%lld\n",querySum(l,r));
}
else if( op == 3 )
{
x = get();
y = get();
insert(y,x);
}
else
{
l = get();
r = get();
x = get();
addInterval(l,r,x);
}
}
}

inline void getArray(char str[],int value[],int st)    //将字符串str中的数字写到value中去，自st开始，返回最后的num,无前导零
{
int i , j , t , negative ;
for( i = 0 , j = st ; str[i] ; i++) if((str[i]>=48&&str[i]<=57)||str[i]=='-')
{
if(str[i]=='-') negative = -1 , i++;
else negative = 1 ;
t = 0 ;
while(str[i]>=48&&str[i]<=57) t = (t<<1)+(t<<3)+(str[i++]^48) ;
value[j++] = t*negative ;
}
}

char str[maxn*5] ;
int main()
{
int i , j ;
while( scanf("%d%d",&n,&m) == 2 )
{
tree[0].init();
tree[0].size = 0 ;
tree[1].p = 0 ;
root = k = 1 ;
getchar();
gets(str);
getArray(str,array,1);

build(1,n+2);
work();
}
return 0 ;
}