思路

首先可以看一下 P4145，在 P4145 中使用了一种叫势能线段树的 Trick。

对于势能线段树，我个人的理解是，对于一段区间（或一个点）直接暴力维护，在经过很少的次数后操作将没有意义的题就可以使用势能线段树。

在本题中，如果没有推平操作，显然我们可以直接使用势能线段树，时间复杂度可以轻松做到 \(\Theta(n \log n)\)。

但是拥有了推平操作，我们可以造出 1，2 操作交替进行的数据，将这类普通的势能线段树卡死。

那么，我们需要考虑优化。发现如果有一段区间的值都是相同的，我们就可以轻松的修改出这段区间在修改后的信息。

因此，考虑再维护两个信息 \(\max\) 和 \(\min\)，当 \(\max = \min\) 时才修改。那么在极限数据在也能做到 \(\Theta(n \log n \log v)\) 的时间复杂度解决。（其中 \(v\) 为值域）

Code

#include <bits/stdc++.h>  
#define int long long  
#define re register  
  
using namespace std;  
  
const int N = 5e5 + 10;  
int n,q;  
int arr[N];  
  
struct seg{  
    #define ls(u) (u << 1)  
    #define rs(u) (u << 1 | 1)  
  
    struct node{  
        int l;  
        int r;  
        int sum;  
        int Max;  
        int Min;  
        int tag;  
    }tr[N << 2];  
  
    inline void pushup(int u){  
        tr[u].sum = tr[ls(u)].sum + tr[rs(u)].sum;  
        tr[u].Max = max(tr[ls(u)].Max,tr[rs(u)].Max);  
        tr[u].Min = min(tr[ls(u)].Min,tr[rs(u)].Min);  
    }  
  
    inline void pushdown(int u){  
        if (~tr[u].tag){  
            tr[ls(u)].sum = (tr[ls(u)].r - tr[ls(u)].l + 1) * tr[u].tag;  
            tr[ls(u)].Max = tr[u].Max;  
            tr[ls(u)].Min = tr[u].Min;  
            tr[ls(u)].tag = tr[u].tag;  
            tr[rs(u)].sum = (tr[rs(u)].r - tr[rs(u)].l + 1) * tr[u].tag;  
            tr[rs(u)].Max = tr[u].Max;  
            tr[rs(u)].Min = tr[u].Min;  
            tr[rs(u)].tag = tr[u].tag;  
            tr[u].tag = -1;  
        }  
    }  
  
    inline void build(int u,int l,int r){  
        tr[u] = {l,r};  
        tr[u].tag = -1;  
        if (l == r){  
            tr[u].sum = tr[u].Max = tr[u].Min = arr[l];  
            return;  
        }  
        int mid = l + r >> 1;  
        build(ls(u),l,mid);  
        build(rs(u),mid + 1,r);  
        pushup(u);  
    }  
  
    inline void modify_div(int u,int l,int r,int k){  
        if (l <= tr[u].l && tr[u].r <= r){  
            if (tr[u].Max == tr[u].Min){  
                tr[u].Max /= k;  
                tr[u].Min /= k;  
                tr[u].tag = tr[u].Max;  
                tr[u].sum = (tr[u].r - tr[u].l + 1) * tr[u].Max;  
                return;  
            }  
        }  
        pushdown(u);  
        int mid = tr[u].l + tr[u].r >> 1;  
        if (l <= mid) modify_div(ls(u),l,r,k);  
        if (r > mid) modify_div(rs(u),l,r,k);  
        pushup(u);  
    }  
  
    inline void modify_upd(int u,int l,int r,int k){  
        if (l <= tr[u].l && tr[u].r <= r){  
            tr[u].sum = (tr[u].r - tr[u].l + 1) * k;  
            tr[u].Max = tr[u].Min = k;  
            tr[u].tag = k;  
            return;  
        }  
        pushdown(u);  
        int mid = tr[u].l + tr[u].r >> 1;  
        if (l <= mid) modify_upd(ls(u),l,r,k);  
        if (r > mid) modify_upd(rs(u),l,r,k);  
        pushup(u);  
    }  
  
    inline int query(int u,int l,int r){  
        if (l <= tr[u].l && tr[u].r <= r) return tr[u].sum;  
        pushdown(u);  
        int res = 0;  
        int mid = tr[u].l + tr[u].r >> 1;  
        if (l <= mid) res += query(ls(u),l,r);  
        if (r > mid) res += query(rs(u),l,r);  
        return res;  
    }  
  
    #undef ls  
    #undef rs  
}tree;  
  
inline int read(){  
    int r = 0,w = 1;  
    char c = getchar();  
    while (c < '0' || c > '9'){  
        if (c == '-') w = -1;  
        c = getchar();  
    }  
    while (c >= '0' && c <= '9'){  
        r = (r << 3) + (r << 1) + (c ^ 48);  
        c = getchar();  
    }  
    return r * w;  
}  
  
signed main(){  
    n = read();  
    q = read();  
    for (re int i = 1;i <= n;i++) arr[i] = read();  
    tree.build(1,1,n);  
    while (q--){  
        int op;  
        op = read();  
        if (op == 1){  
            int l,r,x;  
            l = read();  
            r = read();  
            x = read();  
            tree.modify_div(1,l,r,x);  
        }  
        else if (op == 2){  
            int l,r,x;  
            l = read();  
            r = read();  
            x = read();  
            tree.modify_upd(1,l,r,x);  
        }  
        else{  
            int l,r;  
            l = read();  
            r = read();  
            printf("%lld\n",tree.query(1,l,r));  
        }  
    }  
    return 0;  
}