Sasha and Array（线段树+矩阵快速幂）

原创于 2021-10-27 16:22:01 发布 · 489 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#矩阵 #线性代数

Sasha and Array

[link](Problem - C - Codeforces)

题意

给你一个序列 $a_n$ ，每个序列记录了斐波那契数列的第 $a_i$ 项。现在给你两个操作：

$1\ l\ r\ x$ 将 $[l, r]$ 区间每个数加x。
$1\ l\ r$ 输出 $[l, r]$ 区间每个第 $a_i$ 项的斐波那契的值的和。

题解

我们可以用一个矩阵来存第 $f [i], f [i - 1]$ 项，然后用另一个矩阵 $=\begin{bmatrix} 1&1\\1&0 \end{bmatrix}\quad$ 来对进行对他的转移也就是完成递推的过程，因为矩阵乘法是具有结合律的所以是可以用快速幂进行加速的。

考虑用线段树来维护这两个操作，对于某一个点加x相当与对他乘一个转移矩阵的x次幂。进而发现当我们要对一个区间进行加x的时候，相当于 $(f_l + f_{l + 1}+ f_{l + 2}...f_{r})\times c^x$ ,矩阵乘法具有左分配律和右分配律，也就是我们可以直接维护一个区间的 $f$ 矩阵对这个矩阵变化，这样就从单点修改变成了区间修改了，查询就是找到对应区间的 $f$ 的位置相加即可。

注意sum和lazy都应该存一个矩阵，如果lazy存现在的幂次的话用的太多了会 $T$ 。

Code

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <set>
#include <queue>
#include <vector>
#include <map>
#include <unordered_map>
#include <cmath> 
#include <stack>
#include <iomanip>
#include <deque> 
#include <sstream>
#define x first
#define y second

using namespace std;
typedef long double ld;
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
typedef unsigned long long ULL;
const int N = 1e5 + 10, M = 2 * N, INF = 0x3f3f3f3f, mod = 1e9 + 7;
const double eps = 1e-8;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
int h[N], e[M], ne[M], w[M], idx;
void add(int a, int b, int v = 0) {
    e[idx] = b, w[idx] = v, ne[idx] = h[a], h[a] = idx ++;
}
int n, m, k;
struct Mat {
    LL x[2][2];
    void init() {
        x[0][0] = x[1][1] = 1;
        x[1][0] = x[0][1] = 0;
    }
    Mat operator *(const Mat &a) const {
        Mat res;
        res.x[0][0] = res.x[0][1] = res.x[1][0] = res.x[1][1] = 0;
        for (int k = 0; k < 2; k ++ )
            for (int i = 0; i < 2; i ++ )
                for (int j = 0; j < 2; j ++ )
                    res.x[i][j] = (res.x[i][j] + x[i][k] * a.x[k][j]) % mod;
        return res;
    }
    Mat operator +(const Mat& a) const {
        Mat res;
        for (int i = 0; i < 2; i ++ ) 
            for (int j = 0; j < 2; j ++ )
                res.x[i][j] = (x[i][j] + a.x[i][j]) % mod;
        return res;
    }
};
Mat get_n(LL n) {
    Mat f, c;
    c.x[1][1] = 0, c.x[0][1] = c.x[0][0] = c.x[1][0] = 1; // f变成了自己
    f.init();
    while (n) {
        if (n & 1) f = f * c;
        c = c * c;
        n >>= 1;
    }
    return f;
}
struct Node {
    int l, r;
    Mat f, lazy;
}tr[N << 2];
void pushup(int u) {
    tr[u].f = tr[u << 1].f + tr[u << 1 | 1].f;
}
void down(Node &t, Mat lazy) {
    t.f = t.f * lazy;
    t.lazy = t.lazy * lazy;
}
void down(int u) {
     down(tr[u << 1], tr[u].lazy), down(tr[u << 1 | 1], tr[u].lazy), tr[u].lazy.init();
}
void build(int u, int l, int r) {
    tr[u] = {l, r}, tr[u].f.init(), tr[u].lazy.init();
    if (l == r) {
        tr[u].f = get_n(w[l] - 1); // f[0][0] 是第i + 1项
        return ;
    }
    int mid = l + r >> 1;
    build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
    pushup(u);
}
void modify(int u, int l, int r, Mat x) {
    if (l <= tr[u].l && tr[u].r <= r) {
        down(tr[u], x);
        return ;
    }
    down(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if (l <= mid) modify(u << 1, l, r, x);
    if (r > mid) modify(u << 1 | 1, l, r, x);
    pushup(u);
}
LL query(int u, int l, int r) {
    if (l <= tr[u].l && tr[u].r <= r)     return tr[u].f.x[0][0];
    int mid = tr[u].l + tr[u].r >> 1;
    down(u);
    LL res = 0;
    if (l <= mid) res += query(u << 1, l, r);
    if (r > mid) res = (res + query(u << 1 | 1, l ,r) + mod) % mod;
    return res;
}
int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    cin >> n >> m;
    for (int i = 1; i <= n; i ++ ) cin >> w[i];
    build(1, 1, n);
    while (m --) {
        int op; cin >> op;
        if (op == 1) {
            int l, r, x; cin >> l >> r >> x;
            Mat c = get_n(x);
            modify(1, l, r, c);
        }
        else {
            int l, r; cin >> l >> r;
            cout << query(1, l, r) << endl;        
        }
    }
    return 0;
}
// 1 1 2 3 5 8
// 1 1 1 
// 2 3 2