Codeforces 446C 线段树 递推Fibonacci公式

聪哥推荐的题目

区间修改和区间查询，但是此题新颖之处就在于他的区间修改不是个定值，而是从L 到 R 分别加 F1、F2、。。。Fr-l+1 （F为斐波那契数列）

想了一下之后，觉得用fib的前缀和来解决，每次做懒惰标记记录下当前区间是从哪个L开始加起的，敲了一半之后发现有问题，就跟上次遇到的懒惰标记问题一样，这是个覆盖性的懒惰标记，每次向下传递后，都要先清除孩子的，清除孩子的也有可能要清除son's son，所以要一直pushdown下去，否则就会错，但这样就会超时。

能不能有个累加型的标记让我不用pushdown呢，网上都用的什么二次剩余定理，实在不会

后来发现一个博客的做法相当精妙，利用了斐波那契的特性

我们知道 fib总是由两个两个往后推得  则

若当前 数列前两项 为 a 、b，则之后的必为  a+b a+2b 2a+3b 3a+5b

推完发现 只要知道前两项，后面的任意一项都可以马上出来，因为其系数也满足fib数列

令 K=1,0,1,1,2.。。Ki=Ki-1+Ki-2,。

再令 F=0,1,1,2,3.。。为普通fib数列

则知道 前两项为 a,b,可推算出任意一项 n=Kn*a+Gn*b；

同理，我们可以推算出来，知道前两项后，前n项的总和为

Fn*a+Sn*b（S为fib的前缀和）。

这样的话，我只要每次懒惰标记当前区间的前两项，向下传递就会马上得到区间的加值，并且传递给左右孩子的时候，能根据右孩子的区间不同，马上把前两项变为适合右孩子的那两项。。。最重要的是，这个前两项支持累加，也就是累加型懒惰标记，不用彻底向下传递，这真的是极好的

#include <iostream>
#include <cstdio>
#include <cstring>
#define LL __int64
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
const LL M=;
const int N=+;
LL F[N],K[N],G[N],A[N];
int n,m;
LL d[N<<],f[N<<],f1[N<<],f2[N<<];
void init()
{
    F[]=G[]=;
    K[]=;
    F[]=;
    G[]=;
    K[]=;
    for (int i=;i<=n+;i++){
        F[i]=F[i-]+F[i-];
        K[i]=K[i-]+K[i-];
        G[i]=G[i-]+F[i-];
        if (F[i]>=M) F[i]%=M;
        if (K[i]>=M) K[i]%=M;
        if (G[i]>=M) G[i]%=M;
    }
    for (int i=;i<=n;i++) scanf("%d",&A[i]);
}
void up(int rt)
{
    d[rt]=d[rt<<]+d[rt<<|];
    if (d[rt]>=M) d[rt]%=M;
}
void build(int rt,int l,int r)
{
    f[rt]=;
    if (l>=r){
        d[rt]=A[l]%M;
        return;
    }
    int mid=(l+r)>>;
    build(lson);
    build(rson);
    up(rt);
}
void fix(LL v1,LL v2,int L,int R,int rt,int l,int r);
void pushdown(int rt,int l,int r)
{
    if (l>=r) return;
    if (!f[rt]) return;
    int mid=(l+r)>>;
    fix(f1[rt],f2[rt],l,mid,lson);

    LL t1=K[mid-l+]*f1[rt]%M+K[mid-l+]*f2[rt]%M;
    LL t2=K[mid-l+]*f1[rt]%M+K[mid-l+]*f2[rt]%M;
    if (t1>=M) t1%=M;
    if (t2>=M) t2%=M;
    fix(t1,t2,mid+,r,rson);
    f[rt]=;

}
void fix(LL v1,LL v2,int L,int R,int rt,int l,int r)
{
    if (L==l && r==R){ //采用这种锁定区间的方法是因为下面有个地方要用L计算，我之前的那种写法会出错
        d[rt]+=(v1*F[R-L+]%M+G[R-L+]*v2%M)%M;
        if (d[rt]>=M) d[rt]%=M;
        if (!f[rt]){
            f1[rt]=v1%M;
            f2[rt]=v2%M;
            f[rt]=;
        }
        else{
            f1[rt]+=v1%M;
            f2[rt]+=v2%M;
            if (f1[rt]>=M) f1[rt]%=M;
            if (f2[rt]>=M) f2[rt]%=M;
        }
        return;
    }
    int mid=(l+r)>>;
    pushdown(rt,l,r);
    if (R<=mid) fix(v1,v2,L,R,lson);
    else if (L>mid) fix(v1,v2,L,R,rson);
    else {
        fix(v1,v2,L,mid,lson);
        LL t1=K[mid-L+]*v1%M+K[mid-L+]*v2%M;//这里L要进行计算，每个孩子对应唯一L，所以为什么我要采用这种锁定区间的方式，就是因为这里。以前以为两种锁定区间的方法差不多，现在找到区别了，如果只是简单为了锁定区间，两种都可以用，但是当区间要作为计算条件的时候，要采取这种方法避免错误
        LL t2=K[mid-L+]*v1%M+K[mid-L+]*v2%M;
        if (t1>=M) t1%=M;
        if (t2>=M) t2%=M;
        fix(t1,t2,mid+,R,rson);
    }
    up(rt);
}
LL query(int L,int R,int rt,int l,int r)
{
    if (L<=l && r<=R){
        return d[rt]%M;
    }
    pushdown(rt,l,r);
    int mid=(l+r)>>;
    LL ret1=,ret2=;
    if (L<=mid) ret1=query(L,R,lson);
    if (R>mid) ret2=query(L,R,rson);
    return (ret1+ret2)%M;
}
int main()
{
    int op,a,b;
    while (scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        build(,,n);
        while (m--)
        {
            scanf("%d%d%d",&op,&a,&b);
            if (op==){
                fix(,,a,b,,,n);
            }
            else{
                LL ans=query(a,b,,,n);
                printf("%I64d\n",ans);
            }
        }
    }
    return ;
}