ZOJ 3772 Calculate the Function [线段树+矩阵乘法]【思维?】

本文介绍了一种结合线段树和矩阵乘法解决特定斐波那契数列问题的方法,通过构建矩阵来加速查询过程,实现高效计算。

题目链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3772
————————————————————————————————————————————
Calculate the Function


Time Limit: 2 Seconds Memory Limit: 65536 KB


You are given a list of numbers A1 A2 .. AN and M queries. For the i-th query:

The query has two parameters Li and Ri.
The query will define a function Fi(x) on the domain [Li, Ri] ∈ Z.
Fi(Li) = ALi
Fi(Li + 1) = A(Li + 1)
for all x >= Li + 2, Fi(x) = Fi(x - 1) + Fi(x - 2) × Ax

You task is to calculate Fi(Ri) for each query. Because the answer can be very large, you should output the remainder of the answer divided by 1000000007.

Input
There are multiple test cases. The first line of input is an integer T indicates the number of test cases. For each test case:

The first line contains two integers N, M (1 <= N, M <= 100000). The second line contains N integers A1 A2 .. AN (1 <= Ai <= 1000000000).

The next M lines, each line is a query with two integer parameters Li, Ri (1 <= Li <= Ri <= N).

Output
For each test case, output the remainder of the answer divided by 1000000007.

Sample Input
1
4 7
1 2 3 4
1 1
1 2
1 3
1 4
2 4
3 4
4 4

Sample Output
1
2
5
13
11
4
4
————————————————————————————————————————————
题目大意:

给一段序列 对于每一段查询区间,序列的值为
Fi(x)= ALiALi+1Fi(x1)+Fi(x2)×Axx=Lix=Li+1x>=Li+2

解题思路:

训练的时候一直想 会有什么技巧/黑科技一类的将其转化成一个O(1)查询的问题

最后还是没有想出来,最后看了题解 才知道这是一个线段树+矩阵乘法的

跟那个博主一样进入了 矩阵一定是求高次幂的误区

这题就是fibonacci数列
[ Fi(x+1)0Fi(x)0]×[ 1Ax+210]=[ Fi(x+2)0Fi(x+1)0]

我们只要用线段树处理出一段区间的右矩阵的乘积就好了

查询就变成了 O((log2(n)2)3)

附本题代码
———————————————————————————————————————————

#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;

const int N   = 100000+7;
const int M   = 2;
const int MOD = 1e9+7;

struct Matrix{
    LL m[M][M];
    void clear0(){
        for(int i=0;i<M;i++)
            for(int j=0;j<M;j++)
                m[i][j]=0;
    }
    void clearE(){
        for(int i=0;i<M;i++)
            for(int j=0;j<M;j++)
                m[i][j]=(i==j);
    }

};

Matrix operator * (Matrix a,Matrix b){
    Matrix c;
    c.clear0();

    for(int k=0;k<M;k++){
        for(int i=0;i<M;i++){
            for(int j=0;j<M;j++){
                c.m[i][j]=(c.m[i][j]+a.m[i][k]*b.m[k][j]+MOD)%MOD;
            }
        }
    }
    return c;
}

struct node{
    Matrix a;
    int l,r;
}tree[N<<2];
int w[N];

#define ll (rt<<1)
#define rr (rt<<1|1)
#define mid  ((r+l)>>1)

void pushup(int rt){
    tree[rt].a=tree[ll].a*tree[rr].a;
}

void build(int rt,int l,int r){
    tree[rt].l=l,tree[rt].r=r;
    if(l==r){
        tree[rt].a.m[0][0]=1   ,tree[rt].a.m[0][1]=1;
        tree[rt].a.m[1][0]=w[l],tree[rt].a.m[1][1]=0;
        return ;
    }
    build(ll,l,mid);
    build(rr,mid+1,r);
    pushup(rt);
}

Matrix query(int rt,int L,int R){
    if(L<=tree[rt].l&&tree[rt].r<=R)   return tree[rt].a;

    Matrix ans,b;ans.clearE();
    int md = (tree[rt].l+tree[rt].r)>>1;
    if(L<=md) b=query(ll,L,R),ans=ans*b;
    if(R> md) b=query(rr,L,R),ans=ans*b;
    return ans;
}

Matrix a,b;

void ask(int l,int r){
    if(l==r||l+1==r){
        printf("%d\n",w[r]);
        return ;
    }

    a.m[0][0]=w[l+1],a.m[0][1]=w[l];
    a.m[1][0]=0     ,a.m[1][1]=0;
    b=query(1,l+2,r);
    b=a*b;
    printf("%d\n",b.m[0][0]);

    return  ;
}

int main(){
    int _;
    scanf("%d",&_);
    while(_--){
        int n,m;
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++){
            scanf("%d",&w[i]);
        }

        build(1,1,n);

        int l,r;
        while(m--){
            scanf("%d%d",&l,&r);
            ask(l,r);
        }
    }
    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、付费专栏及课程。

余额充值