Luogu 4433 [COCI2009-2010#1] ALADIN

LOJ 2958

线段树 + 类欧

主要矛盾就是$\sum\limits_{i = l}^{r}Ai \mod B$怎么做。

拆成前缀和相减的形式，有

$$\sum_{i = 0}^{r}(Ai \mod B) - \sum_{i = 0}^{l - 1}(Ai \mod B)$$

我们知道

$$a \mod b = a - \left \lfloor \frac{a}{b} \right \rfloor b$$

那么

$$\sum_{i = 0}^{n}Ai \mod B = \sum_{i = 0}^{n} Ai - \left \lfloor \frac{Ai}{B} \right \rfloor B = \frac{An(n + 1)}{2} - B\sum_{i = 0}^{n}\left \lfloor \frac{Ai}{B} \right \rfloor$$

后面那个东西就是类欧模板中的$f(A, 0, B, n)$。

还有一件事情：$10^9 * 2 * 10^9 / 2 * 10^6 = 10^{24} > long\ long$，所以我写了一个$\text{__int128}$。

因为标记一定要下传，所以似乎不能动态开点而需要离散，但是离散之后注意到线段树一个结点左右儿子可能并不是连续的。

举个栗子，假如我们离散完之后的序列是${1, 5, 7, 9}$，那么一号结点对应的区间是$[1, 9]$，而它的左儿子是$[1, 5]$，右儿子是$[7, 9]$，中间还有一段$[6, 6]$的空缺。所以我们在$up$和算答案的时候需要考虑这段空缺的贡献（可能是我线段树没学好qwq）。

这样子的话效率就很迷人了。

时间复杂度$O(qlog^2n)$。

Code：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef __int128 ILL;

const int N = 1e5 + ;

int n, qn, tot = , buc[N];

struct Options {
    int op, l, r, A, B;
} q[N];

namespace Fread {
    const int L =  << ;

    char buffer[L], *S, *T;

    inline char Getchar() {
        if(S == T) {
            T = (S = buffer) + fread(buffer, , L, stdin);
            if(S == T) return EOF;
        }
        return *S++;
    }

    template <class T>
    inline void read(T &X) {
        char ch; T op = ;
        for(ch = Getchar(); ch > '' || ch < ''; ch = Getchar())
            if(ch == '-') op = -;
        for(X = ; ch >= '' && ch <= ''; ch = Getchar())
            X = (X << ) + (X << ) + ch - '';
        X *= op;
    }

} using namespace Fread;   

namespace Fwrite {
    const int L =  << ;

    char buf[L], *pp = buf;

    void Putchar(const char c) {
        if(pp - buf == L) fwrite(buf, , L, stdout), pp = buf;
        *pp++ = c;
    }

    template<typename T>
    void print(T x) {
        if(x < ) {
            Putchar('-');
            x = -x;
        }
        if(x > ) print(x / );
        Putchar(x %  + '');
    }

    void fsh() {
        fwrite(buf, , pp - buf, stdout);
        pp = buf;
    }

    template <typename T>
    inline void write(T x, char ch = ) {
        print(x);
        if (ch != ) Putchar(ch);
        fsh();
    }

} using namespace Fwrite;

namespace LikeGcd {
    ILL solve(ILL a, ILL b, ILL c, ILL n) {
        if (!a) return (b / c) * (n + );
        if (a >= c || b >= c)
            return (a / c) * n * (n + ) /  + (b / c) * (n + ) + solve(a % c, b % c, c, n);
        if (a < c && b < c) {
            ILL m = (a * n + b) / c;
            return n * m - solve(c, c - b - , a, m - );
        }
        return ;
    }
}

namespace SegT {
    struct Node {
        int st, A, B;
        ll sum;
        bool tag;
    } s[N << ];

    #define lc p << 1
    #define rc p << 1 | 1
    #define mid ((l + r) >> 1)
    #define st(p) s[p].st
    #define A(p) s[p].A
    #define B(p) s[p].B
    #define sum(p) s[p].sum
    #define tag(p) s[p].tag

    inline ll calc(int p, int st, int en) {
//        int st = st(p), en = st(p) + buc[r] - buc[l];
        if (!B(p)) return ;
        ILL res = ;
        res += (ILL)A(p) * (ILL)(st + en) * (ILL)(en - st + ) / (ILL);
        res -= (ILL)B(p) * (LikeGcd :: solve(A(p), , B(p), en) - LikeGcd :: solve(A(p), , B(p), st - ));
        return 1LL * res;
    }

    inline void up(int p, int l, int r) {
        sum(p) = sum(lc) + sum(rc);
        if (buc[mid] +  != buc[mid + ]) {
            sum(p) += calc(p, st(p) + buc[mid] +  - buc[l], st(p) + buc[mid + ] -  - buc[l]);
        }
    }

    inline void down(int p, int l, int r) {
        if (!tag(p)) return;
        st(lc) = st(p), st(rc) = st(p) + buc[mid + ] - buc[l];
        A(lc) = A(rc) = A(p);
        B(lc) = B(rc) = B(p);
        tag(lc) = tag(rc) = ;
        sum(lc) = calc(lc, st(lc), st(lc) + buc[mid] - buc[l]);
        sum(rc) = calc(rc, st(rc), st(rc) + buc[r] - buc[mid + ]);
        tag(p) = ;
    }

    void modify(int p, int l, int r, int x, int y, int A, int B) {
        if (x <= l && y >= r) {
            tag(p) = ;
            st(p) = buc[l] - buc[x] + , A(p) = A, B(p) = B;
            sum(p) = calc(p, st(p), st(p) + buc[r] - buc[l]);
            return;
        }

        down(p, l, r);

        if (x <= mid) modify(lc, l, mid, x, y, A, B);
        if (y > mid) modify(rc, mid + , r, x, y, A, B);
        if (buc[mid + ] != buc[mid] + ) {
            if (buc[x] <= buc[mid] +  && buc[y] >= buc[mid + ] - ) {
                A(p) = A, B(p) = B;
                st(p) = buc[l] - buc[x] + ;
            }
        }

        up(p, l, r);
    }

    ll query(int p, int l, int r, int x, int y) {
        if (x <= l && y >= r) return sum(p);
        down(p, l, r);

        ll res = ;
        if (x <= mid) res += query(lc, l, mid, x, y);
        if (y > mid) res += query(rc, mid + , r, x, y);
        if (buc[mid + ] != buc[mid] + ) {
            if (buc[y] >= buc[mid] +  && buc[x] <= buc[mid + ] - ) {
                int ln = max(buc[mid] + , buc[x]);
                int rn = min(buc[mid + ] - , buc[y]);
                res += calc(p, st(p) + ln - buc[l], st(p) + rn - buc[l]);
            }
        }

        return res;
    }

    void ddd(int p, int l, int r) {
        if (l == r) return;
        down(p, l, r);
        ddd(lc, l, mid), ddd(rc, mid + , r);
    }

} using namespace SegT;

int main() {
/*    #ifndef ONLINE_JUDGE
        freopen("input.txt", "r", stdin);
    #endif      */

    read(n), read(qn);
    for (int i = ; i <= qn; i++) {
        read(q[i].op), read(q[i].l), read(q[i].r);
        buc[++tot] = q[i].l, buc[++tot] = q[i].r;
        if (q[i].op == ) read(q[i].A), read(q[i].B);
    }

    sort(buc + , buc +  + tot);
    tot = unique(buc + , buc +  + tot) - buc - ;

//    for (int i = 1; i <= tot; i++)
//        printf("%d%c", buc[i], " \n"[i == tot]);     

    for (int i = ; i <= qn; i++) {
        q[i].l = lower_bound(buc + , buc +  + tot, q[i].l) - buc;
        q[i].r = lower_bound(buc + , buc +  + tot, q[i].r) - buc;
    }

    for (int i = ; i <= qn; i++) {
        if (q[i].op == ) modify(, , tot, q[i].l, q[i].r, q[i].A, q[i].B);
        else write(query(, , tot, q[i].l, q[i].r), '\n');

/*        ddd(1, 1, tot);
        printf("\n");
        for (int j = 1; j <= 9; j++)
            printf("%d %lld %d %d %d\n", j, sum(j), A(j), B(j), st(j));    */
    }

    return ;
}