bzoj 4127 线段树维护绝对值之和

因为d>=0,所以一个位置的数只会单调不降并且只会有一次穿过0.

用这个性质,我们我可在线段树中记录正数负数的个数和和,以及最大的负数以及答案.

修改操作:如果当前最大负数+d<=0,那么就直接加到懒惰标记中,否则就暴力向下传递.

因为每个节点最多被额外访问该区间负数个数次,所以所有点总共会被额外访问O(nlogn)次,在加上修改操作和询问操作的普通访问O(mlogn)次,所以时间复杂度是有保证的.

谢谢mhy12345的讲解.

 /**************************************************************
     Problem: 4127
     User: idy002
     Language: C++
     Result: Accepted
     Time:7872 ms
     Memory:49256 kb
 ****************************************************************/

 #include <cstdio>
 #include <vector>
 #include <algorithm>
 #define min(a,b) ((a)<(b)?(a):(b))
 #define max(a,b) ((a)>(b)?(a):(b))
 #define abs(a) ((a)<0?-(a):(a))
 #define oo 0x3f3f3f3f3f3f3f3fLL
 #define N 200010
 //#define fprintf(...)
 using namespace std;

 typedef long long dnt;

 void getn( int &v ) {
     char ch=getchar();
     bool neg = false;
     while( ch!='-' && (ch<'' || ch>'') ) ch=getchar();
     if( ch=='-' ) {
         neg = true;
         ch = getchar();
     }
     v = ch-'';
     ch = getchar();
     while( ''<=ch && ch<='' ) {
         v = v*+ch-'';
         ch = getchar();
     }
     if( neg ) v=-v;
 }

 struct Node {
     dnt ans, sum[], cnt[], nmx, tag;
     Node *ls, *rs;
     inline void init( int v ) {
         if( v< ) {
             sum[] = v;
             cnt[] = ;
             sum[] = ;
             cnt[] = ;
             ans = -v;
             tag = ;
             nmx = v;
         } else {
             sum[] = ;
             cnt[] = ;
             sum[] = v;
             cnt[] = ;
             tag = ;
             ans = v;
             nmx = -oo;
         }
     }
     inline void update() {
         sum[] = ls->sum[] + rs->sum[];
         sum[] = ls->sum[] + rs->sum[];
         cnt[] = ls->cnt[] + rs->cnt[];
         cnt[] = ls->cnt[] + rs->cnt[];
         ans = ls->ans + rs->ans;
         nmx = max( ls->nmx, rs->nmx );
     }
     inline void pushdown() {
         if( tag ) {
             ls->nmx += tag;
             rs->nmx += tag;
             ls->sum[] += ls->cnt[]*tag;
             ls->sum[] += ls->cnt[]*tag;
             rs->sum[] += rs->cnt[]*tag;
             rs->sum[] += rs->cnt[]*tag;
             ls->ans = ls->sum[]-ls->sum[];
             rs->ans = rs->sum[]-rs->sum[];
             ls->tag += tag;
             rs->tag += tag;
             tag = ;
         }
     }
     void modify( int lf, int rg, int L, int R, int delta ) {
         if( lf==rg ) {
             if( cnt[] ) {
                 if( sum[]+delta<= ) {
                     sum[]+=delta;
                     nmx = sum[];
                     ans = -sum[];
                 } else {
                     sum[] = sum[]+delta;
                     ans = sum[];
                     cnt[] = ;
                     sum[] = cnt[] = ;
                     nmx = -oo;
                 }
             } else {
                 sum[]+=delta;
                 ans = sum[];
             }
             return;
         }
         if( L<=lf && rg<=R && nmx+delta<= ) {
             nmx += delta;
             sum[] += cnt[]*delta;
             sum[] += cnt[]*delta;
             ans = sum[]-sum[];
             tag += delta;
             return;
         }
         pushdown();
         int mid=(lf+rg)>>;
         if( L<=mid ) ls->modify(lf,mid,L,R,delta);
         if( R>mid ) rs->modify(mid+,rg,L,R,delta);
         update();
     }
     dnt query( int lf, int rg, int L, int R ) {
         if( L<=lf && rg<=R ) return ans;
         pushdown();
         int mid=(lf+rg)>>;
         dnt rt = ;
         if( L<=mid ) rt+=ls->query(lf,mid,L,R);
         if( R>mid ) rt+=rs->query(mid+,rg,L,R);
         update();
         return rt;
     }
 }pool[N*], *tail=pool, *root;

 int n, m;
 int aa[N], bb[N];
 int head[N], dest[N<<], next[N<<], etot;
 int fat[N], siz[N], son[N], top[N], dep[N], vid[N], qu[N], bg, ed;

 void adde( int u, int v ) {
     etot++;
     dest[etot] = v;
     next[etot] = head[u];
     head[u] = etot;
 }
 Node *build( int lf, int rg ) {
     Node *nd = ++tail;
     if( lf==rg) {
         nd->init(bb[lf]);
         return nd;
     }
     int mid=(lf+rg)>>;
     nd->ls = build( lf, mid );
     nd->rs = build( mid+, rg );
     nd->update();
     return nd;
 }
 void build_dcp( int s ) {
     //  fat dep
     fat[s] = ;
     dep[s] = ;
     qu[bg=ed=] = s;
     while( bg<=ed ) {
         int u=qu[bg++];
         for( int t=head[u]; t; t=next[t] ) {
             int v=dest[t];
             if( v==fat[u] ) continue;
             fat[v] = u;
             dep[v] = dep[u]+;
             qu[++ed] = v;
         }
     }
     //  siz son
     for( int i=ed; i>=; i-- ) {
         int u=qu[i], p=fat[u];
         siz[u]++;
         if( p ) {
             siz[p] += siz[u];
             if( siz[son[p]]<siz[u] ) son[p]=u;
         }
     }
     //  vid top
     vid[s] = ;
     top[s] = s;
     for( int i=; i<=ed; i++ ) {
         int u=qu[i];
         int cur=vid[u]+;
         if( son[u] ) {
             vid[son[u]] = cur;
             top[son[u]] = top[u];
             cur += siz[son[u]];
         }
         for( int t=head[u]; t; t=next[t] ) {
             int v=dest[t];
             if( v==fat[u] || v==son[u] ) continue;
             vid[v] = cur;
             top[v] = v;
             cur += siz[v];
         }
     }
     //  segment tree
     for( int i=; i<=n; i++ )
         bb[vid[i]] = aa[i];
 //  for( int i=1; i<=n; i++ )
 //      fprintf( stderr, "%d ", bb[i] );
 //  fprintf( stderr, "\n" );
     root = build( , n );
 }
 void modify( int u, int v, int delta ) {
     while( top[u]!=top[v] ) {
         if( dep[top[u]]<dep[top[v]] ) swap(u,v);
         root->modify(,n,vid[top[u]],vid[u],delta);
 //      fprintf( stderr, "modify( %d %d %d )\n", vid[top[u]], vid[u], delta );
         u=fat[top[u]];
     }
     if( dep[u]<dep[v] ) swap(u,v);
     root->modify(,n,vid[v],vid[u],delta);
 //  fprintf( stderr, "modify( %d %d %d )\n", vid[v], vid[u], delta );
 }
 dnt query( int u, int v ) {
     dnt rt = ;
     while( top[u]!=top[v] ) {
         if( dep[top[u]]<dep[top[v]] ) swap(u,v);
         rt += root->query(,n,vid[top[u]],vid[u]);
 //      fprintf( stderr, "query( %d %d ) rt = %lld\n", vid[top[u]], vid[u], rt );
         u=fat[top[u]];
     }
     if( dep[u]<dep[v] ) swap(u,v);
     rt += root->query(,n,vid[v],vid[u]);
 //  fprintf( stderr, "query( %d %d ) rt = %lld\n", vid[v], vid[u], rt );
     return rt;
 }
 int main() {
     getn(n); getn(m);
     for( int i=; i<=n; i++ )
         getn(aa[i]);
     for( int i=,u,v; i<n; i++ ) {
         getn(u); getn(v);
         adde( u, v );
         adde( v, u );
     }
     build_dcp();
     for( int t=,opt,u,v,d; t<=m; t++ ) {
         getn(opt);
         if( opt== ) {
             getn(u);getn(v);getn(d);
             modify( u, v, d );
         } else {
             getn(u); getn(v);
             printf( "%lld\n", query(u,v) );
         }
     }
 }