zoj3772【线段树+矩阵相乘】

Calculate the Function

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

You are given a list of numbers A₁ A₂ .. A_N and M queries. For the i-th query:

• The query has two parameters L_i and R_i.
• The query will define a function F_i(x) on the domain [L_i, R_i] ∈ Z.
• F_i(L_i) = A_Li
• F_i(L_i + 1) = A_{(Li + 1)}
• for all x >= L_i + 2, F_i(x) = F_i(x - 1) + F_i(x - 2) × A_x

You task is to calculate F_i(R_i) 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 A₁ A₂ .. A_N (1 <= A_i <= 1000000000).

The next M lines, each line is a query with two integer parameters L_i, R_i (1 <= L_i <= R_i <= 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

 题目大意很简单：就告诉你一个公式然后进行询问

分析：

这是昨天训练赛的题目

比赛的时候还没看

昨晚我以为是推公式进行求解

半天推出来的公式是错的TAT

其实我应该想到的

数据范围10^5若是公式的话不应该这么小的范围

这个的复杂度应该是一个nlog(n)的级别

后来周洲他们队结束之后a了

我打开第一眼

线段树

那时候脑袋里突然就想到了大概的方向

其实很简单的

F1, F2  可以推得 F2, F3

我们可以找到这么一个矩阵使其完成那个功能  

这个矩阵我得到的是

1      1

a[3]  0

那么继续往下推

就是继续乘以矩阵

1      1

a[3]  0

每次都乘会超时

那么我们用线段树在存储就可以了

每个节点存的是该节点下的矩阵的子矩阵的乘积

最后查询的时候只要把它和F1, F2相乘就可以了

代码：

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

const long long maxn = 100005;
const long long mod = 1000000007;
long long val[maxn];
long long start[1][2];
long long end[1][2];

struct Node {
    long long b[2][2];
};
struct Tree {
    long long left, right;
    Node node;
}tree[maxn << 2];

Node mul(Node n1, Node n2) {
    Node n3;
    for(long long i = 0; i < 2; i++) {
        for(long long j = 0; j < 2; j++) {
            n3.b[i][j] = 0;
            for(long long k = 0; k < 2; k++) {
                n3.b[i][j] += n1.b[i][k] * n2.b[k][j];
                n3.b[i][j] %= mod;
            }
        }
    }
    return n3;
}

Node Build(long long root, long long left, long long right) {
    tree[root].left = left; tree[root].right = right;
    if(left == right) {
        tree[root].node.b[0][0] = 1; tree[root].node.b[0][1] = 1;
        tree[root].node.b[1][0] = val[left]; tree[root].node.b[1][1] = 0;
        return tree[root].node;
    }
    long long mid = ( left + right ) >> 1;
    return tree[root].node = mul(Build(root << 1, left, mid), Build(root << 1 | 1, mid + 1, right));
}

Node x;
void init() {
    x.b[0][0] = 1; x.b[0][1] = 0;
    x.b[1][0] = 0; x.b[1][1] = 1;
}

Node cal(long long root, long long left, long long right) {
    if(tree[root].left > right || tree[root].right < left) {
        return x;
    }
    if(left <= tree[root].left && tree[root].right <= right) {
        return tree[root].node;
    }
    return mul(cal(root << 1, left, right), cal(root << 1 | 1, left, right) );
}

int main() {
    long long t, n, m;
    long long a, b;
    init();
    scanf("%lld",&t);
    while(t--) {
        scanf("%lld %lld",&n, &m);
        for(long long i = 1; i <= n; i++) {
            scanf("%lld",&val[i]);
        }
        Build(1, 1, n);
        while(m--) {
            scanf("%lld %lld",&a, &b);
            if(b <= a + 1) {
                printf("%lld
",val[b]);
                continue;
            }
            start[0][0] = val[a + 1]; start[0][1] = val[a];
            Node mid = cal(1, a + 2, b);
            for(long long i = 0; i < 1; i++) {
                for(long long j = 0; j < 2; j++) {
                    end[i][j] = 0;
                    for(long long k = 0; k < 2; k++) {
                        end[i][j] += start[i][k] * mid.b[k][j];
                        end[i][j] %= mod;
                    }
                }
            }
            printf("%lld
", end[0][0]);
        }
    }
    return 0;
}