Solution -「LOJ #6029」「雅礼集训 2017」市场

$\mathcal{Description}$

  Link.

  维护序列 $\lang a_n\rang$，支持 $q$ 次如下操作：

1. 区间加法；

2. 区间下取整除法；

3. 区间求最小值；

4. 区间求和。

   $n,q\le10^5$，值域大约是 $V=2\times10^9$。

$\mathcal{Solution}$

  可以推测是势能线段树。对于线段树上的区间 $[l,r]$，想要将它 $\div d$，维护 $u=\min_{i=l}^r\{a_i\}$ 以及 $v=\max_{i=l}^r\{a_i\}$，当 $\lfloor\frac{u}{d}\rfloor-u=\lfloor\frac{v}{d}\rfloor-v$ 时直接打区间加法标记，否则递归处理。其他操作正常在线段树上进行，若不考虑各变量间的数量级关系，可证复杂度为 $\mathcal O((n+q\log n)\log V)$。

证明

  设线段树上区间 $[l,r]$ 有势能 $\Phi[l,r]=\log(v-u)$（$v,u$ 定义如上），总势能 $\Phi=\sum\Phi[l,r]$，则：

• 初始状态，$\Phi[l,r]\le\mathcal O(\log V)$，$\Phi\le\mathcal O(n\log V)$；
• 区间加法，势能有变动的区间个数为 $\mathcal O(\log n)$，$\Delta\Phi[l,r]\le\mathcal O(\log V)$，故 $\Delta\Phi=\sum\Delta\Phi[l,r]\le\mathcal O(\log n\log V)$；
• 区间除法，设操作对象为区间 $[s,e]$，首先其有基础复杂度开销 $\mathcal O(\log n)$，也有可能带来至多 $\mathcal O(\log n\log V)$ 的势能增加。考虑树上一个被它完全覆盖的区间 $[l,r]$。若在这个区间需要向下递归，则必然有 $\Delta\Phi[l,r]\le-1$，所以 $\Delta\Phi\propto x$，其中 $x$ 即递归入完全覆盖区间的次数。那么本次操作的复杂度为 $\mathcal O(\log n+x)$。

  综上，总复杂度为 $\mathcal O(q\log n)+\sum x$，即 $\mathcal O(q\log n+n\log V+q\log n\log V)$，当然第一项可以忽略。 $\square$

$\mathcal{Code}$

/*~Rainybunny~*/

#include <cmath>
#include <cstdio>

#define rep( i, l, r ) for ( int i = l, rep##i = r; i <= rep##i; ++i )
#define per( i, r, l ) for ( int i = r, per##i = l; i >= per##i; --i )

typedef long long LL;
#define int LL

inline int rint() {
    int x = 0, f = 1, s = getchar();
    for ( ; s < '0' || '9' < s; s = getchar() ) f = s == '-' ? -f : f;
    for ( ; '0' <= s && s <= '9'; s = getchar() ) x = x * 10 + ( s ^ '0' );
    return x * f;
}

template<typename Tp>
inline void wint( Tp x ) {
    if ( x < 0 ) putchar( '-' ), x = -x;
    if ( 9 < x ) wint( x / 10 );
    putchar( x % 10 ^ '0' );
}

inline int imin( const int a, const int b ) { return a < b ? a : b; }
inline int imax( const int a, const int b ) { return a < b ? b : a; }

const int MAXN = 1e5, IINF = 1ll << 60;
int n, q;

struct SegmentTree {
    int len[MAXN << 2], mx[MAXN << 2], mn[MAXN << 2], adt[MAXN << 2];
    LL sum[MAXN << 2];

    inline void pushup( const int u ) {
        mx[u] = imax( mx[u << 1], mx[u << 1 | 1] );
        mn[u] = imin( mn[u << 1], mn[u << 1 | 1] );
        sum[u] = sum[u << 1] + sum[u << 1 | 1];
    }


    inline void pushad( const int u, const int v ) {
        adt[u] += v, mn[u] += v, mx[u] += v, sum[u] += 1ll * v * len[u];
    }

    inline void pushdn( const int u ) {
        if ( adt[u] ) {
            pushad( u << 1, adt[u] ), pushad( u << 1 | 1, adt[u] );
            adt[u] = 0;
        }
    }

    inline void build( const int u, const int l, const int r ) {
        len[u] = r - l + 1;
        if ( l == r ) return void( mx[u] = mn[u] = sum[u] = rint() );
        int mid = l + r >> 1;
        build( u << 1, l, mid ), build( u << 1 | 1, mid + 1, r );
        pushup( u );
    }

    inline void add( const int u, const int l, const int r,
      const int al, const int ar, const int v ) {
        if ( al <= l && r <= ar ) return pushad( u, v );
        int mid = l + r >> 1; pushdn( u );
        if ( al <= mid ) add( u << 1, l, mid, al, ar, v );
        if ( mid < ar ) add( u << 1 | 1, mid + 1, r, al, ar, v );
        pushup( u );
    }

    inline void div( const int u, const int l, const int r,
      const int dl, const int dr, const int v ) {
        // if ( v == 1 ) return ;
        if ( dl <= l && r <= dr && mx[u] - floor( 1. * mx[u] / v )
          == mn[u] - floor( 1. * mn[u] / v ) ) {
            return pushad( u, floor( 1. * mx[u] / v ) - mx[u] );
        }
        int mid = l + r >> 1; pushdn( u );
        if ( dl <= mid ) div( u << 1, l, mid, dl, dr, v );
        if ( mid < dr ) div( u << 1 | 1, mid + 1, r, dl, dr, v );
        pushup( u );
    }

    inline int qmin( const int u, const int l, const int r,
      const int ql, const int qr ) {
        if ( ql <= l && r <= qr ) return mn[u];
        int mid = l + r >> 1, ret = IINF; pushdn( u );
        if ( ql <= mid ) ret = imin( ret, qmin( u << 1, l, mid, ql, qr ) );
        if ( mid < qr )
            ret = imin( ret, qmin( u << 1 | 1, mid + 1, r, ql, qr ) );
        return ret;
    }

    inline LL qsum( const int u, const int l, const int r,
      const int ql, const int qr ) {
        if ( ql <= l && r <= qr ) return sum[u];
        int mid = l + r >> 1; LL ret = 0; pushdn( u );
        if ( ql <= mid ) ret += qsum( u << 1, l, mid, ql, qr );
        if ( mid < qr ) ret += qsum( u << 1 | 1, mid + 1, r, ql, qr );
        return ret;
    }
} sgt;

signed main() {
    n = rint(), q = rint();
    sgt.build( 1, 0, n - 1 );
    for ( int op, l, r; q--; ) {
        op = rint(), l = rint(), r = rint();
        if ( op == 1 ) sgt.add( 1, 0, n - 1, l, r, rint() );
        else if ( op == 2 ) sgt.div( 1, 0, n - 1, l, r, rint() );
        else if ( op == 3 ) wint( sgt.qmin( 1, 0, n - 1, l, r ) ), puts( "" );
        else wint( sgt.qsum( 1, 0, n - 1, l, r ) ), puts( "" );
    }
    return 0;
}