EOJ3534 笋尖爆炸（线段树+斐波那契数列性质）

本文链接：https://blog.youkuaiyun.com/hnust_Derker/article/details/79924144

思路：
$\ \ \ \$ 因为斐波那契序列具有可加性，可以对每个区间记录是以哪两项作为斐波那契序列前两项的值，延迟标记一下，对于 $x,y$ 的路径上更新值 $u, v$ 的时候， $x$ 位置单独加 $u，x + 1$ 位置单独加 $v$ ，然后 $[x + 2,y]$ 的位置加入 $u, v$ ，对于 $[l, r]$ 这个区间的时候，添加的 $u,v$ 不是简单直接添加，而是是记录经过 $[l - ql + 1]$ 项之后的两项斐波那契数，可以用递推矩阵解决，关于区间求和，也可以用递推矩阵求，设 $S_n$ 是斐波那契序列前 $n$ 项和，那么有：

[\begin{matrix} S_{n} \\ F_{n + 1} \\ F_{n} \end{matrix}] = [\begin{matrix} 1 & 1 & 0 \\ 0 & 1 & 1 \\ 0 & 1 & 0 \end{matrix}] * [\begin{matrix} S_{n - 1} \\ F_{n} \\ F_{n - 1} \end{matrix}]

$\begin {bmatrix} S_n \\F_{n+1} \\ F_n \end {bmatrix} = \begin {bmatrix} 1 & 1 & 0 \\ 0 & 1 & 1 \\ 0 & 1 & 0 \end {bmatrix} * \begin {bmatrix} S_{n-1} \\F_{n} \\ F_{n-1} \end {bmatrix}$

$\ \ \ \$ 而这个矩阵的次幂最大是

nn $n$ 项，所以斐波那契序列的矩阵和求和矩阵都可以预处理出来，之后延迟更新的时候就把这些步骤给省略了，时间复杂度

O ((2^{3} + 3^{3}) n + m \log n)

$O((2^3+3^3)n + m \log n)$ ，常数有点大。

$\$

#include<bits/stdc++.h>
typedef long long ll;
const int maxn = 4e5 + 10;
const ll mod = 998244353;
using namespace std;

typedef pair<ll, ll> pa;
typedef vector<ll> vec;
typedef vector<vec> mat;
int n, m, T, kase = 1;
ll sum[2][maxn * 4], lu[2][maxn * 4], lv[2][maxn * 4];

ll sum_A[maxn][3][3], ans_A[maxn][2][2];

void init() {
    mat as(3, vec(3));
    mat aa(2, vec(2));
    mat ansA(2, vec(2));
    mat sumA(3, vec(3));
    for(int i = 0; i < 2; i++) {
        ans_A[0][i][i] = 1;
        ansA[i][i] = 1;
    }
    for(int i = 0; i < 3; i++) {
        sum_A[0][i][i] = 1;
        sumA[i][i] = 1;
    }
    for(int i = 0; i < 2; i++) {
        for(int j = 0; j < 2; j++) {
            aa[i][j] = (!i || !j);
        }
    }
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            as[i][j] = 1;
        }
    }
    as[0][2] = as[1][0] = as[2][0] = as[2][2] = 0;
    for(int i = 1; i < maxn; i++) {
        for(int j = 0; j < 2; j++) {
            for(int k = 0; k < 2; k++) {
                for(int x = 0; x < 2; x++) {
                    ans_A[i][j][k] = (ans_A[i][j][k] + ans_A[i - 1][j][x] * aa[x][k]) % mod;
                }
            }
        }
        for(int j = 0; j < 3; j++) {
            for(int k = 0; k < 3; k++) {
                for(int x = 0; x < 3; x++) {
                    sum_A[i][j][k] = (sum_A[i][j][k] + sum_A[i - 1][j][x] * as[x][k]) % mod;
                }
            }
        }
    }
}

pa fib(ll f1, ll f2, ll n) {
    n -= 2;
    ll Fn = (ans_A[n][0][0] * f2 + ans_A[n][0][1] * f1) % mod;
    ll Fn_1 = (ans_A[n][1][0] * f2 + ans_A[n][1][1] * f1) % mod;
    return pa(Fn_1, Fn);
}

ll get_sum(ll f1, ll f2, ll n) {
    n += 2;
    ll tot = (sum_A[n - 1][0][0] * f1 + sum_A[n - 1][0][1] * f2 + sum_A[n - 1][0][2] * f1) % mod;
    tot = tot - f2;
    if(tot < 0) tot += mod;
    tot = tot - f1;
    if(tot < 0) tot += mod;
    return tot;
}

void push_down(int flag, int o, int l, int r, int mid) {
    if(!lu[flag][o] && !lv[flag][o]) return ;
    ll tot_l = mid - l + 1;
    ll tot_r = r - mid;
    pa lt = fib(lu[flag][o], lv[flag][o], tot_l + 2);
    lu[flag][o << 1] += lu[flag][o];
    lv[flag][o << 1] += lv[flag][o];
    lu[flag][o << 1 | 1] += lt.first;
    lv[flag][o << 1 | 1] += lt.second;
    sum[flag][o << 1] += get_sum(lu[flag][o], lv[flag][o], tot_l);
    sum[flag][o << 1 | 1] += get_sum(lt.first, lt.second, tot_r);
    if(lu[flag][o << 1] >= mod) lu[flag][o << 1] -= mod;
    if(lv[flag][o << 1] >= mod) lv[flag][o << 1] -= mod;
    if(sum[flag][o << 1] >= mod) sum[flag][o << 1] -= mod;
    if(lu[flag][o << 1 | 1] >= mod) lu[flag][o << 1 | 1] -= mod;
    if(lv[flag][o << 1 | 1] >= mod) lv[flag][o << 1 | 1] -= mod;
    if(sum[flag][o << 1 | 1] >= mod) sum[flag][o << 1 | 1] -= mod;
    lu[flag][o] = lv[flag][o] = 0;
}

void push_up(int flag, int o) {
     sum[flag][o] = (sum[flag][o << 1] + sum[flag][o << 1 | 1]);
     if(sum[flag][o] >= mod) sum[flag][o] -= mod;
}

void update(int flag, int o, int l, int r, int ql, int qr, ll f1, ll f2) {
    if(l > qr || r < ql) return ;
    if(l >= ql && r <= qr) {
        pa now = fib(f1, f2, l - ql + 2);
        lu[flag][o] = (now.first + lu[flag][o]);
        if(lu[flag][o] >= mod) lu[flag][o] -= mod;
        lv[flag][o] = (now.second + lv[flag][o]);
        if(lv[flag][o] >= mod) lv[flag][o] -= mod;
        ll res = get_sum(now.first, now.second, r - l + 1);
        sum[flag][o] = (sum[flag][o] + res) - mod;
        if(sum[flag][o] < 0) sum[flag][o] += mod;
        return ;
    }
    int mid = (l + r) >> 1;
    push_down(flag, o, l, r, mid);
    update(flag, o << 1, l, mid, ql, qr, f1, f2);
    update(flag, o << 1 | 1, mid + 1, r, ql, qr, f1, f2);
    push_up(flag, o);
}

void add_val(int flag, int o, int l, int r, int ind, ll val) {
    if(l == r) {
        sum[flag][o] = (sum[flag][o] + val);
        if(sum[flag][o] >= mod) sum[flag][o] -= mod;
        return ;
    }
    int mid = (l + r) >> 1;
    push_down(flag, o, l, r, mid);
    if(ind <= mid) add_val(flag, o << 1, l, mid, ind, val);
    else add_val(flag, o << 1 | 1, mid + 1, r, ind ,val);
    push_up(flag, o);
}

ll query(int flag, int o, int l, int r, int ql, int qr) {
    if(l > qr || r < ql) return 0;
    if(l >= ql && r <= qr) return sum[flag][o];
    int mid = (l + r) >> 1;
    push_down(flag, o, l, r, mid);
    ll p1 = query(flag, o << 1, l, mid, ql, qr);
    ll p2 = query(flag, o << 1 | 1, mid + 1, r, ql, qr);
    return (p1 + p2) % mod;
}

ll query(int l, int r) {
    ll a1 = query(0, 1, 1, n, l, r);
    l = n - l + 1; r = n - r + 1;
    ll a2 = query(1, 1, 1, n, r, l);
    return (a1 + a2) % mod;
}

int main() {
    init();
    while(scanf("%d %d", &n, &m) != EOF) {
        for(int i = 0; i < 4 * maxn; i++)
            for(int j = 0; j < 2; j++)
                sum[j][i] = lu[j][i] = lv[j][i] = 0;
        while(m--) {
            int op, u, v, x, y;
            scanf("%d", &op);
            if(op == 2) {
                scanf("%d %d", &u, &v);
                if(u > v) swap(u, v);
                printf("%lld\n", query(u, v));
            } else {
                scanf("%d %d %d %d", &x, &y, &u, &v);
                int fg = (x > y);
                if(x > y) { x = n - x + 1; y = n - y + 1; }
                add_val(fg, 1, 1, n, x, u);
                if(x + 1 <= y) add_val(fg, 1, 1, n, x + 1, v);
                if(x + 2 <= y) update(fg, 1, 1, n, x + 2, y, u, v);
            }
        }
    }
    return 0;
}