Codeforces #316E3: Summer Homework 题解

最新推荐文章于 2019-07-18 20:48:00 发布

IcePrincess_1968

最新推荐文章于 2019-07-18 20:48:00 发布

阅读量384

点赞数

分类专栏：线段树 ----------数据结构---------- ----------数学---------- 矩阵文章标签： Codeforces 矩阵线段树

本文链接：https://blog.csdn.net/IcePrincess_1968/article/details/80155139

版权

----------数据结构---------- 同时被 3 个专栏收录

21 篇文章 0 订阅

订阅专栏

----------数学----------

16 篇文章 0 订阅

订阅专栏

线段树

15 篇文章 0 订阅

订阅专栏

这样的题肯定要维护线段树，重点是如何维护裴波那契数列使得可以很快的进行合并操作
这里给出一个很骚的操作：
对于每个区间维护两个值:
1. $f_0*a_l+f_1*a_{l+1}+...$
2. $f_1*a_l+f_2*a_{l+1}+...$
我们发现这个序列的转移方式和裴波那契数列一样：只要拿 $f_{i-1}$ 和 $f_i$ 开头的多项式相加，就能得到下一个 $f_{i+1}$ 开头的多项式，也就是说，如果每个区间我们把上述两个式子写成一个矩阵，每次只要乘一个转移矩阵的若干次方就能得到以任意 $f_i$ 开头的多项式
这样我们考虑线段树合并两个区间的时候，只要将右边的矩阵乘上转移矩阵的“左边长度”次方，再把两个矩阵相加就好了
这样我们已经搞定了单点修改和区间查询
我们考虑区间加操作，会发现给一个区间+delta事实上给这个区间加上了一个裴波那契数列的前缀和的delta倍，于是懒标记可以维护了

PS:很卡常；卡常小技巧：能不用long long就不要用long long，哪怕遇到乘法的时候再临时转long long，这样效率几乎能提高一倍

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <cstdlib>
#include <utility>
#include <cctype>
#include <algorithm>
#include <bitset>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <cmath>
#define LL long long
#define LB long double
#define x first
#define y second
#define Pair pair<int,int>
#define pb push_back
#define pf push_front
#define mp make_pair
#define LOWBIT(x) x & (-x)
using namespace std;

const int MOD=1e9;
const LL LINF=2e16;
const int INF=2e9;
const int magic=348;
const double eps=1e-10;
const double pi=acos(-1);

inline int getint()
{
    char ch;int res;bool f;
    while (!isdigit(ch=getchar()) && ch!='-') {}
    if (ch=='-') f=false,res=0; else f=true,res=ch-'0';
    while (isdigit(ch=getchar())) res=res*10+ch-'0';
    return f?res:-res;
}

int n,q;
inline int mod(LL x)
{
    while (x>=MOD) x-=MOD;
    return x;
}

struct Matrix
{
    int b[3][3];
    inline void init()
    {
        b[1][1]=0;
        b[1][2]=b[2][1]=b[2][2]=1;
    }
    inline void clear() {for (register int i=1;i<=2;i++) for (register int j=1;j<=2;j++) b[i][j]=0;}
    inline Matrix operator + (const Matrix ma)
    {
        Matrix res;res.clear();int i,j;
        for (i=1;i<=2;i++)
            for (j=1;j<=2;j++)
                res.b[i][j]=mod(res.b[i][j]+mod(b[i][j]+ma.b[i][j]));
        return res;
    }
    inline Matrix operator * (const Matrix ma)
    {
        Matrix res;res.clear();int i,j,k;
        for (i=1;i<=2;i++)
            for (j=1;j<=2;j++)
                for (k=1;k<=2;k++)
                    res.b[i][j]=mod(res.b[i][j]+((long long)b[i][k]*ma.b[k][j])%MOD);
        return res;
    }
    inline Matrix operator ^ (const Matrix ma)
    {
        Matrix res;res.b[1][1]=res.b[1][2]=0;int j,k;
        for (j=1;j<=2;j++)
            for (k=1;k<=2;k++)
                res.b[1][j]=mod(res.b[1][j]+((long long)b[1][k]*ma.b[k][j])%MOD);
        return res;
    }
    inline Matrix operator & (const Matrix ma)
    {
        Matrix res;res.b[1][1]=res.b[1][2]=0;int j;
        for (j=1;j<=2;j++) res.b[1][j]=mod(res.b[1][j]+mod(b[1][j]+ma.b[1][j]));
        return res;
    }
    //这里的&和^和上面的+和*是一样的，只不过为了卡常数写了一个矩阵
    //只有上面一行的卡常版本，毕竟我的代码是压线过的...
}trans,ma[200048];
LL fib[200048],sum1[200048],sum2[200048];
int a[200048];

namespace SegmentTree
{
    struct node
    {
        int left,right,len,lazy;
        Matrix ma;
    }tree[1000048];
    inline Matrix pushup(Matrix x,Matrix y,int starter)
    {
        if (starter) y=y^ma[starter];x=x&y;
        return x;
    }
    inline void pushdown(int cur)
    {
        tree[cur<<1].lazy=mod(tree[cur<<1].lazy+tree[cur].lazy);
        tree[cur<<1|1].lazy=mod(tree[cur<<1|1].lazy+tree[cur].lazy);
        tree[cur].lazy=0;
    }
    inline Matrix calc_lazy(Matrix x,int ind)
    {
        if (tree[ind].lazy==0) return x;
        x.b[1][1]=mod(x.b[1][1]+((long long)tree[ind].lazy*sum1[tree[ind].len])%MOD);
        x.b[1][2]=mod(x.b[1][2]+((long long)tree[ind].lazy*sum2[tree[ind].len])%MOD);
        return x;
    }
    inline void build(int cur,int left,int right)
    {
        tree[cur].left=left;tree[cur].right=right;tree[cur].lazy=0ll;
        tree[cur].len=tree[cur].right-tree[cur].left+1;
        if (left!=right)
        {
            int mid=(left+right)>>1;
            build(cur<<1,left,mid);
            build(cur<<1|1,mid+1,right);
            tree[cur].ma=pushup(tree[cur<<1].ma,tree[cur<<1|1].ma,tree[cur<<1].len);
        }
        else
        {
            tree[cur].ma.b[1][1]=tree[cur].ma.b[1][2]=a[left];
            tree[cur].ma.b[2][1]=tree[cur].ma.b[2][2]=0;
        }
    }
    inline void update(int cur,int pos,int newval)
    {
        if (tree[cur].left==tree[cur].right)
        {
            tree[cur].ma.b[1][1]=tree[cur].ma.b[1][2]=newval;
            tree[cur].lazy=0;
            return;
        }
        pushdown(cur);
        int mid=(tree[cur].left+tree[cur].right)>>1;
        if (pos<=mid) update(cur<<1,pos,newval); else update(cur<<1|1,pos,newval);
        tree[cur].ma=pushup(calc_lazy(tree[cur<<1].ma,cur<<1),calc_lazy(tree[cur<<1|1].ma,cur<<1|1),tree[cur<<1].len);
    }
    inline Matrix query(int cur,int left,int right,int starter)
    {
        Matrix res;res.clear();
        if (left<=tree[cur].left && tree[cur].right<=right) return calc_lazy(tree[cur].ma,cur)*ma[starter];
        pushdown(cur);
        int mid=(tree[cur].left+tree[cur].right)>>1;
        if (left>mid) {res=query(cur<<1|1,left,right,starter);}
        else if (right<=mid) {res=query(cur<<1,left,right,starter);}
        else {Matrix res1=query(cur<<1,left,tree[cur<<1].right,starter),res2=query(cur<<1|1,tree[cur<<1|1].left,right,starter+mid-left+1);res=res1+res2;}
        tree[cur].ma=pushup(calc_lazy(tree[cur<<1].ma,cur<<1),calc_lazy(tree[cur<<1|1].ma,cur<<1|1),tree[cur<<1].len);
        return res;
    }
    inline void update(int cur,int left,int right,int delta)
    {
        if (left<=tree[cur].left && tree[cur].right<=right) {tree[cur].lazy=mod(tree[cur].lazy+delta);return;}
        pushdown(cur);
        int mid=(tree[cur].left+tree[cur].right)>>1;
        if (left<=mid) update(cur<<1,left,right,delta);
        if (mid+1<=right) update(cur<<1|1,left,right,delta);
        tree[cur].ma=pushup(calc_lazy(tree[cur<<1].ma,cur<<1),calc_lazy(tree[cur<<1|1].ma,cur<<1|1),tree[cur<<1].len);
    }
}

int main ()
{
    n=getint();q=getint();
    int i,type,pos,newval,l,r,delta;
    trans.init();ma[0].b[1][1]=ma[0].b[2][2]=1;ma[0].b[1][2]=ma[0].b[2][1]=0;
    for (i=1;i<=n+10;i++) ma[i]=ma[i-1]*trans;
    for (i=1;i<=n;i++) a[i]=getint();
    fib[1]=fib[2]=1;for (i=3;i<=n+10;i++) fib[i]=mod(fib[i-1]+fib[i-2]);
    sum1[1]=sum2[1]=1;for (i=2;i<=n+9;i++) sum1[i]=mod(sum1[i-1]+fib[i]),sum2[i]=mod(sum2[i-1]+fib[i+1]);
    SegmentTree::build(1,1,n);
    while (q--)
    {
        type=getint();
        if (type==1)
        {
            pos=getint();newval=getint();
            SegmentTree::update(1,pos,newval);
        }
        if (type==2)
        {
            l=getint();r=getint();
            printf("%d\n",SegmentTree::query(1,l,r,0).b[1][1]);
        }
        if (type==3)
        {
            l=getint();r=getint();delta=getint();
            SegmentTree::update(1,l,r,delta);
        }
    }
    return 0;
}
/*
5 5
1 3 1 2 4
2 1 4
2 1 5
2 2 4
1 3 10
2 1 5
*/

IcePrincess_1968

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Codeforces #316E3: Summer Homework 题解

这样的题肯定要维护线段树，重点是如何维护裴波那契数列使得可以很快的进行合并操作这里给出一个很骚的操作：对于每个区间维护两个值: 1. f0∗al+f1∗al+1+...f0∗al+f1∗al+1+...f_0*a_l+f_1*a_{l+1}+... 2. f1∗al+f2∗al+1+...f1∗al+f2∗al+1+...f_1*a_l+f_2*a_{l+1}+... 我们发现这个序...
复制链接

扫一扫