【NOIP2013模拟联考13】线段

题目大意

一开始有一个全部为1的无限长的序列，有两种区间修改的操作，一个是给区间内的数都乘上$w$，第二个是给区间内的数都取$w$次幂，只有一种询问，询问区间内的数的乘积。

解法一

离散化之后用线段树维护一个区间的数的乘积，还有两个懒标记（懒标记应该都懂，我就不说了，不懂的就看 http://ju.outofmemory.cn/entry/99351），一个是乘上的数，一个是取多少次幂，作乘积操作时直接修改乘积的懒操作，作乘幂操作时将懒标记中的乘积取$w$次幂，次幂乘上$w$。
时间复杂度：$O(n log_2 n)$

解法二

解法二的操作方法与线段树的基本相同，但这种算法在时间允许的情况下是完全可以代替线段树的，在有些题目中，甚至是只有它可以解而线段树不能，这种算法就是：分块！！！
请允许我默念：
分块大法好！！！
分块大法好！！！
分块大法好！！！
下面我来简单介绍一下分块的基本思想。
分块，可以支持区间修改，单点修改，区间查询，单点查询（难道各位想用分块做单点修改单点查询？！）
将序列分成$\sqrt n$块，每块的大小大致为$\sqrt n+1$，简单的说，就是将$a_1$到$a_{\sqrt n+1}$分成一块，将$a_{\sqrt n+2}$到$a_{(2\sqrt n+2)}$分成一块，以此类推，最后剩下的一些再分成一块（读者可以想一想为什么每块大小要大致为$\sqrt n+1$）。
同线段树，对于每一块可能有多个懒标记，这根据题目而定。
单点修改：找到这个点所属的块，将标记下传之后修改。
区间修改：找出开头和结尾所属的块，在他们之间的块就修改懒标记，然后将开头和结尾所属的块的标记下传，暴力修改头和尾中不可以直接靠修改区间标记来达到修改目的的位置。
单点查询：与单点修改类似，找到这个点所属的块，将标记下传之后查询。
区间查询：与区间修改类似，找出开头和结尾所属的块，在他们之间的块就直接查询整块的答案，然后将开头和结尾所属的块的标记下传，暴力查询头和尾中不可以直接靠查询区间来达到查询目的的位置。
听起来好暴力！！！！
但是，让我们来计算一下其时间复杂度，单点修改$O(\sqrt n)$，区间修改$O(\sqrt n)$，单点查询$O(\sqrt n)$，区间查询$O(\sqrt n)$， 所以最终的复杂度是$O(n^{1.5})$。
所以只要数据范围可以，时间允许，这个算法就可能是正解！！！
最后来一句：
分块大法好！！！
分块大法好！！！
分块大法好！！！
好吧，不是一句，因为一句已经不能表达我内心的兴奋了！！！

回到题目，有了上面对于分块的描述，读者就可以分块解决这题了，其修改询问都与线段树类似，让后就完美解决了！
我也手打了一次分块，但是经我细心发现，出题的打的肯定是线段树，因为数据中出现了0的0次幂，但它在数学上是不存在的，但是打分块的错了，打线段树的都对了！这让我情何以堪！QAQ！！

按照惯例，贴一下代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<numeric>
#include<cstring>
#include<queue>
#include<functional>
#include<set>
#include<map>

#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)

using namespace std;

typedef long long LL;
const int mod = 1000000007;
const int N = 20010;

int get(){
    char ch;
    while (ch=getchar(),(ch<'0'||ch>'9')&& ch!='-');
    char c=ch;
    int s=0;
    if (c!='-')s=c-48;
    while (ch=getchar(),ch>='0'&&ch<='9')s=s*10+ch-48;
    return c=='-'?-s:s;
}


struct section{
    LL ans,mul,mi;
    int tot;
}s[300];
int h[N*2],tot,k,n,m,block,b[N*2];
LL ans;
struct question{
    int ty,x,y;
    LL w;
}a[N];
LL v[N*2],t[N*2];

void init(){
    n=get();
    fo(i,1,n){
        a[i].ty=get();
        a[i].x=get();
        a[i].y=get();
        if (a[i].ty<2)a[i].w=get();
        if (a[i].ty==0)a[i].w%=mod;
        if (a[i].ty==1)a[i].w%=(mod-1);
        h[++tot]=a[i].x;
        h[++tot]=a[i].y;    
    }
}

void prepare(){
    sort(h+1,h+1+tot);
    k=1;
    fo(i,2,tot)
    if (h[i]>h[i-1])h[++k]=h[i];
    h[k+1]=h[k]+1;
    block=int(sqrt(k))+1;
    fo(i,1,k){
        v[i]=1;
        t[i]=h[i+1]-h[i];
        b[i]=(i-1)/block+1;
        s[b[i]].tot+=t[i];
    }
    int su=b[k];
    fo(i,1,su)s[i].ans=s[i].mul=s[i].mi=1;
}

LL quickmi(LL x,int tim){
    LL ans(1);
    while (tim){
        if (tim%2)ans=ans*x%mod;
        x=x*x%mod;
        tim/=2;
    }
    return ans;
}

int ask(int x){
    int l=1,r=k,w(0);
    while (l<=r){
        int mid=(l+r)/2;
        if (x<h[mid])r=mid-1;
        else{
            l=mid+1;
            w=mid;
        }
    }
    return w;
}

void updata(int x){
    fo(i,(x-1)*block+1,min(k,x*block))
        v[i]=quickmi(v[i],s[x].mi)*quickmi(s[x].mul,t[i])%mod;
    s[x].mi=s[x].mul=1;
}

void changemul(int l,int r,int w){
    if (b[l]==b[r]){
        updata(b[l]);
        fo(i,l,r){
            LL x=quickmi(w,t[i]);
            v[i]=v[i]*x%mod;
            s[b[l]].ans=s[b[l]].ans*x%mod;
        }
        return;
    }
    fo(i,b[l]+1,b[r]-1){
        LL x=quickmi(w,s[i].tot);
        s[i].mul=s[i].mul*w%mod;
        s[i].ans=s[i].ans*x%mod;
    }
    updata(b[l]);
    updata(b[r]);
    fo(i,l,min(k,b[l]*block)){
        LL x=quickmi(w,t[i]);
        v[i]=v[i]*x%mod;
        s[b[l]].ans=s[b[l]].ans*x%mod;
    }
    fo(i,(b[r]-1)*block+1,r){
        LL x=quickmi(w,t[i]);
        v[i]=v[i]*x%mod;
        s[b[r]].ans=s[b[r]].ans*x%mod;
    }
}

void changemi(int l,int r,int w){
    if (b[l]==b[r]){
        updata(b[l]);
        fo(i,l,r){
            LL x=quickmi(v[i],(w+mod-1)%mod);
            v[i]=v[i]*x%mod;
            s[b[l]].ans=s[b[l]].ans*x%mod;
        }
        return;
    }
    fo(i,b[l]+1,b[r]-1){
        s[i].mul=quickmi(s[i].mul,w);
        s[i].ans=quickmi(s[i].ans,w)%mod;
        s[i].mi=(s[i].mi*w)%(mod-1);
    }
    updata(b[l]);
    updata(b[r]);
    fo(i,l,min(k,b[l]*block)){
        LL x=quickmi(v[i],(w+mod-1)%mod);
        v[i]=v[i]*x%mod;
        s[b[l]].ans=s[b[l]].ans*x%mod;
    }
    fo(i,(b[r]-1)*block+1,r){
        LL x=quickmi(v[i],(w+mod-1)%mod);
        v[i]=v[i]*x%mod;
        s[b[r]].ans=s[b[r]].ans*x%mod;
    }
}

LL getans(int l,int r){
    LL ans(1);
    if (b[l]==b[r]){
        updata(b[l]);
        fo(i,l,r)
        ans=ans*v[i]%mod;
        return ans;
    }
    fo(i,b[l]+1,b[r]-1)ans=ans*s[i].ans%mod;
    updata(b[l]);
    updata(b[r]);
    fo(i,l,min(k,b[l]*block))ans=ans*v[i]%mod;
    fo(i,(b[r]-1)*block+1,r)ans=ans*v[i]%mod;
    return ans;
}

void solve(){
    fo(i,1,n){
        if (a[i].ty==0)changemul(ask(a[i].x),ask(a[i].y-1),a[i].w);
        if (a[i].ty==1)changemi(ask(a[i].x),ask(a[i].y-1),a[i].w);
        if (a[i].ty==2)printf("%lld\n",getans(ask(a[i].x),ask(a[i].y-1)));
    }
}

int main(){
    freopen("segment.in","r",stdin);
    freopen("segment.out","w",stdout);
    init();
    prepare();
    solve();
}