ZOJ 3772 矩阵 + 线段树

本文介绍了解决ZOJ3772问题的方法,采用节点存储矩阵的方式,并考虑了方向因素。通过ZKW线段树实现矩阵的构建与查询,提供了完整的AC代码。

传送门 :zoj 3772

题解

还是节点存储矩阵, 不过这题各哥节点基矩阵不同, 所以要考虑方向,wa + 3, pe + 1


AC code:

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;

#define mid ((l + r) >> 1)
#define ls rt << 1, l, mid
#define rs rt << 1 | 1, mid + 1, r
typedef long long LL;

const LL MOD = 1000000007;
const LL maxn = 100000 + 5;

int n, M;

struct Matrix{

    LL v[2][2];

    void clr() {
        memset(v, 0, sizeof(v));
    }

    void E() {
        clr();
        for (int i = 0; i < 2; ++i) v[i][i] = 1;
    }

    void init(LL a, LL b, LL c, LL d) {
        v[0][0] = a;
        v[0][1] = b;
        v[1][0] = c;
        v[1][1] = d;
    }

    void debug() {
        for (int i = 0; i < 2; ++i)
            for (int j = 0; j < 2; ++j)
                cout << v[i][j] << (j == 1 ? "\n" : " ");
    }

    Matrix operator * (Matrix b) {
        Matrix res;
        res.clr();

        for (int i = 0; i < 2; ++i)
            for (int j = 0; j < 2; ++j)
                for(int k = 0; k < 2; ++k)
                    res.v[i][j] = (res.v[i][j] + v[i][k] * b.v[k][j]) % MOD;

        return res;
    }

    //Matrix 
}a[maxn << 2];

void build() {//zkw线段树
    LL x;

    for (M = 1; M <= n + 1; M <<= 1);
    for (int i = M + 1; i <= M + n; ++i) {
        scanf("%I64d", &x);
        a[i].init(0, x, 1, 1);
    }

    for (int i = M - 1; i; --i) {
        a[i] = a[i << 1] * a[i << 1 | 1];
    }
}

LL query(int l, int r) {
    int id = l + M;
    l += M + 1;//查询[l + 2, r]的矩阵积, l += M - 1 + 2;
    r += M + 1;

    Matrix tmp, la, ra;
    la.E();
    ra.E();
    //tmp.E();

    while (r ^ l ^ 1) {
        if (~l & 1) la = la * a[l + 1];//方向问题, 后来才反应过来
        if (r & 1) ra = a[r - 1] * ra;
        l >>= 1;
        r >>= 1;
    }
    tmp = la * ra;
    LL res = (a[id].v[0][1] * tmp.v[0][1] + a[id + 1].v[0][1] * tmp.v[1][1]) % MOD;
    if (res < 0) res += MOD;

    return res;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif 

    cin.tie(0);
    cin.sync_with_stdio(false);

    int T, q, l, r;
    scanf("%d", &T);

    while (T--) {
        for (int i = 1; i < maxn << 2; ++i) a[i].E();
        scanf("%d%d", &n, &q);
        build();

        while (q--) {
            scanf("%d%d", &l, &r);
            if(r - l >= 2)  printf("%d\n", query(l, r));
            else printf("%d\n", a[r + M].v[0][1]);
        }
    }

    return 0;
}
### ZOJ 1088 线段树 解题思路 #### 题目概述 ZOJ 1088 是一道涉及动态维护区间的经典问题。通常情况下,这类问题可以通过线段树来高效解决。题目可能涉及到对数组的区间修改以及单点查询或者区间查询。 --- #### 线段树的核心概念 线段树是一种基于分治思想的数据结构,能够快速处理区间上的各种操作,比如求和、最大值/最小值等。其基本原理如下: - **构建阶段**:通过递归方式将原数组划分为多个小区间,并存储在二叉树形式的节点中。 - **更新阶段**:当某一段区间被修改时,仅需沿着对应路径向下更新部分节点即可完成全局调整。 - **查询阶段**:利用懒惰标记(Lazy Propagation),可以在 $O(\log n)$ 时间复杂度内完成任意范围内的计算。 具体到本题,假设我们需要支持以下两种主要功能: 1. 对指定区间 `[L, R]` 执行某种操作(如增加固定数值 `val`); 2. 查询某一位置或特定区间的属性(如总和或其他统计量)。 以下是针对此场景设计的一种通用实现方案: --- #### 实现代码 (Python) ```python class SegmentTree: def __init__(self, size): self.size = size self.tree_sum = [0] * (4 * size) # 存储区间和 self.lazy_add = [0] * (4 * size) # 延迟更新标志 def push_up(self, node): """ 更新父节点 """ self.tree_sum[node] = self.tree_sum[2*node+1] + self.tree_sum[2*node+2] def build_tree(self, node, start, end, array): """ 构建线段树 """ if start == end: # 到达叶节点 self.tree_sum[node] = array[start] return mid = (start + end) // 2 self.build_tree(2*node+1, start, mid, array) self.build_tree(2*node+2, mid+1, end, array) self.push_up(node) def update_range(self, node, start, end, l, r, val): """ 区间更新 [l,r], 加上 val """ if l <= start and end <= r: # 当前区间完全覆盖目标区间 self.tree_sum[node] += (end - start + 1) * val self.lazy_add[node] += val return mid = (start + end) // 2 if self.lazy_add[node]: # 下传延迟标记 self.lazy_add[2*node+1] += self.lazy_add[node] self.lazy_add[2*node+2] += self.lazy_add[node] self.tree_sum[2*node+1] += (mid - start + 1) * self.lazy_add[node] self.tree_sum[2*node+2] += (end - mid) * self.lazy_add[node] self.lazy_add[node] = 0 if l <= mid: self.update_range(2*node+1, start, mid, l, r, val) if r > mid: self.update_range(2*node+2, mid+1, end, l, r, val) self.push_up(node) def query_sum(self, node, start, end, l, r): """ 查询区间[l,r]的和 """ if l <= start and end <= r: # 完全匹配 return self.tree_sum[node] mid = (start + end) // 2 res = 0 if self.lazy_add[node]: self.lazy_add[2*node+1] += self.lazy_add[node] self.lazy_add[2*node+2] += self.lazy_add[node] self.tree_sum[2*node+1] += (mid - start + 1) * self.lazy_add[node] self.tree_sum[2*node+2] += (end - mid) * self.lazy_add[node] self.lazy_add[node] = 0 if l <= mid: res += self.query_sum(2*node+1, start, mid, l, r) if r > mid: res += self.query_sum(2*node+2, mid+1, end, l, r) return res def solve(): import sys input = sys.stdin.read data = input().split() N, Q = int(data[0]), int(data[1]) # 数组大小 和 操作数量 A = list(map(int, data[2:N+2])) # 初始化数组 st = SegmentTree(N) st.build_tree(0, 0, N-1, A) idx = N + 2 results = [] for _ in range(Q): op_type = data[idx]; idx += 1 L, R = map(int, data[idx:idx+2]); idx += 2 if op_type == 'Q': # 查询[L,R]的和 result = st.query_sum(0, 0, N-1, L-1, R-1) results.append(result) elif op_type == 'U': # 修改[L,R]+X X = int(data[idx]); idx += 1 st.update_range(0, 0, N-1, L-1, R-1, X) print("\n".join(map(str, results))) solve() ``` --- #### 关键点解析 1. **初始化与构建**:在线段树创建过程中,需要遍历输入数据并将其映射至对应的叶子节点[^1]。 2. **延迟传播机制**:为了优化性能,在执行批量更新时不立即作用于所有受影响区域,而是记录更改意图并通过后续访问逐步生效[^2]。 3. **时间复杂度分析**:由于每层最多只访问两个子树分支,因此无论是更新还是查询都维持在 $O(\log n)$ 范围内[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值