华南理工大学“三七互娱杯”程序设计竞赛（重现赛）B HRY and fibonacci

题目链接：https://ac.nowcoder.com/acm/contest/874/B

题目大意：

　　设 fib(i) 为第 i 项斐波那契数列：$$fib(0) = 0, fib(1) = 1, fib(i) = fib(i - 1) + fib(i - 2), i geq 2$$

　　利用 fib 序列定义 fic 和 fid 序列：$$fic(n) = sum_{i = 1}^{n} fib(i)$$ $$fid(n) = sum_{i = 1}^{n} fic(i)$$

　　现在给定序列 a₁，a₂……a_n。

　　再给出 2 种操作：

1. 给定区间 [L, R]，对于所有$L leq i leq R$，执行 a_i += x。
2. 给定区间 [L, R]，计算$(sum_{i = L}^{R} fid(i)) \% (1e8 + 7)$，并输出。

分析：

　　先求 fic 的通项：

$$
egin{align*}
fic(n) - fic(n - 1) &= fib(n) \
&= fib(n - 1) + fib(n - 2) \
&= fib(1) + sum_{i = 1}^{n - 2} fib(i) \
&= fib(1) + fic(n - 2) \ \
fic(n) &= fic(n - 1) + fic(n - 2) + 1, fic(1) = 1, fic(2) = 2
end{align*}
$$

　　同理 fid 的通项为：

$$
fid(n) = fid(n - 1) + fid(n - 2) + n, fid(1) = 1, fid(2) = 3
$$

　　fid 的通项其实和 fib 差不多，他们都可以用矩阵快速幂的方法计算第 n 项。

　　构造如下矩阵 M：

$$
M = egin{bmatrix}
1 & 1 & 0 & 0 \
1 & 0 & 0 & 0 \
1 & 0 & 1 & 0 \
1 & 0 & 1 & 1 \
end{bmatrix}
$$

　　再构造如下矩阵 FID(i)：

$$
FID(i) = egin{bmatrix}
fid(i) & fid(i - 1) & i & 1
end{bmatrix} 
$$

　　于是有：

$$
FID(n) = FID(n - 1) * M \
FID(n) = FID(1) * M^{n - 1}
$$

　　由于是区间操作，所以想到用线段树，线段树每个节点维护$sum_{i = L}^{R} FID(a_i)$。

　　由于 Mⁿ 的最后一行恰好就是 FID(n)，因此线段树每个节点只要维护$sum_{i = L}^{R} M^{a_i}$即可。

　　最后说一下我做这道题的坎：

1. 用vector存矩阵，结果超时。
2. 用结构体封装线段树，结果超时，要拿到外面来。
3. 用scanf输入，结果超时，因此用了快速输入函数 ri()。
4. 常规线段树成段更新操作，就是要标懒惰标记然后 pushDown 的，结果超时，然后我取消 pushDown，直接把信息存在懒惰标记里，于是懒惰标记数组就成了线段树的对应参数辅助树，勉强过了。

代码如下：

#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
 
#define INIT() std::ios::sync_with_stdio(false);std::cin.tie(0);
#define Rep(i,n) for (int i = 0; i < (n); ++i)
#define For(i,s,t) for (int i = (s); i <= (t); ++i)
#define rFor(i,t,s) for (int i = (t); i >= (s); --i)
#define ForLL(i, s, t) for (LL i = LL(s); i <= LL(t); ++i)
#define rForLL(i, t, s) for (LL i = LL(t); i >= LL(s); --i)
#define foreach(i,c) for (__typeof(c.begin()) i = c.begin(); i != c.end(); ++i)
#define rforeach(i,c) for (__typeof(c.rbegin()) i = c.rbegin(); i != c.rend(); ++i)

#define pr(x) cout << #x << " = " << x << "  "
#define prln(x) cout << #x << " = " << x << endl
 
#define LOWBIT(x) ((x)&(-x))
 
#define ALL(x) x.begin(),x.end()
#define INS(x) inserter(x,x.begin())
 
#define ms0(a) memset(a,0,sizeof(a))
#define msI(a) memset(a,inf,sizeof(a))
#define msM(a) memset(a,-1,sizeof(a))

#define MP make_pair
#define PB push_back
#define ft first
#define sd second
 
template<typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
    in >> p.first >> p.second;
    return in;
}
 
template<typename T>
istream &operator>>(istream &in, vector<T> &v) {
    for (auto &x: v)
        in >> x;
    return in;
}
 
template<typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
    out << "[" << p.first << ", " << p.second << "]" << "
";
    return out;
}

inline int gc(){
    static const int BUF = 1e7;
    static char buf[BUF], *bg = buf + BUF, *ed = bg;
    
    if(bg == ed) fread(bg = buf, 1, BUF, stdin);
    return *bg++;
} 

inline int ri(){
    int x = 0, f = 1, c = gc();
    for(; c<48||c>57; f = c=='-'?-1:f, c=gc());
    for(; c>47&&c<58; x = x*10 + c - 48, c=gc());
    return x*f;
}
 
typedef long long LL;
typedef unsigned long long uLL;
typedef pair< double, double > PDD;
typedef pair< int, int > PII;
typedef set< int > SI;
typedef vector< int > VI;
typedef vector< LL > VL;
typedef vector< VL > VVL;
typedef map< int, int > MII;
const double EPS = 1e-10;
const int inf = 1e9 + 9;
const LL mod = 1e8 + 7;
const int maxN = 1e5 + 7;
const LL ONE = 1;
const LL evenBits = 0xaaaaaaaaaaaaaaaa;
const LL oddBits = 0x5555555555555555;

struct Matrix{
    const static int sz = 4;
    LL mat[sz][sz];
    
    Matrix() { clear(); }
    Matrix(const VVL &x) {
        Rep(i, sz) {
            Rep(j, sz) {
                mat[i][j] = x[i][j];
            }
        }
    }
    
    // x * 单位阵 
    inline void E(int x = 1) {
        //assert(row == col);
        clear();
        Rep(i, sz) mat[i][i] = x;
    }
    
    inline Matrix operator+ (const Matrix &x) {
        //assert(row == x.row && col == x.col);
        Matrix ret;
        Rep(i, sz) {
            Rep(j, sz) {
                ret.mat[i][j] = (mat[i][j] + x.mat[i][j]) % mod;
            }
        }
        return ret;
    }
    
    inline Matrix operator* (const Matrix &x) {
        //assert(col == x.row);
        Matrix ret;
        Rep(k, sz) {
            Rep(i, sz) {
                if(mat[i][k] == 0) continue;
                Rep(j, sz) {
                    ret.mat[i][j] = (ret.mat[i][j] + mat[i][k] * x.mat[k][j]) % mod;
                }
            }
        }
        return ret;
    }
    
    inline Matrix operator*= (const Matrix &x) { return *this = *this * x; }
    inline Matrix operator+= (const Matrix &x) { return *this = *this + x; }
    
    inline void clear() { ms0(mat); } 
    
    inline void print() {
        Rep(i, sz) {
            Rep(j, sz) {
                cout << mat[i][j] << " ";
            }
            cout << endl;
        }
    }
};

Matrix base[65];
const Matrix M(VVL( {{1, 1, 0, 0}, {1, 0, 0, 0}, {1, 0, 1, 0}, {1, 0, 1, 1}} ));

void initBase() {
    base[1] = M;
    For(i, 2, 64) {
        base[i] = base[i - 1] * base[i - 1];
    }
}

// 矩阵快速幂，计算M^y 
inline Matrix mat_pow_mod(LL y) {
    Matrix ret;
    ret.E();
    int tmp = 1;
    while(y){
        if(y & 1) ret *= base[tmp];
        ++tmp;
        y >>= 1;
    }
    return ret;
}

int n, Q;

#define lson l , mid , rt << 1 
#define rson mid + 1 , r , rt << 1 | 1
Matrix st[maxN << 2];
Matrix lazy[maxN << 2];

inline void pushUp(int rt) {
    st[rt] = (st[rt << 1] + st[rt << 1 | 1]) * lazy[rt];
}

inline void build(int l, int r, int rt) {
    lazy[rt].E();
    if(l >= r) {
        int a = ri();
        st[rt] = mat_pow_mod(a);
        return;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    pushUp(rt);
}

inline void update(int L, int R, Matrix x, int l, int r, int rt) {
    if(L <= l && r <= R) {
        lazy[rt] *= x; // 记录懒惰标记，不再往下更新 
        st[rt] *= x;
        return;
    }
    int mid = (l + r) >> 1;
    if(L <= mid) update(L, R, x, lson);
    if(R > mid) update(L, R, x, rson);
    pushUp(rt);
}

// 查询区间[L, R]和 
inline Matrix query(int L, int R, int l, int r, int rt) {
    if(L <= l && r <= R) return st[rt];
    int mid = (l + r) >> 1;
    Matrix ret;
    if(L <= mid) ret += query(L, R, lson);
    if(R > mid) ret += query(L, R, rson);
    return ret * lazy[rt];
}

int main(){
    //INIT();
    initBase();
    n = ri();
    build(1, n, 1);
    
    Q = ri();
    Rep(i, Q) {
        int mode, l, r;
        mode = ri();
        l = ri();
        r = ri();
        if(mode == 1) update(l, r, mat_pow_mod(ri()), 1, n, 1);
        else printf("%lld
", query(l, r, 1, n, 1).mat[3][0]);
    }
    return 0;
}