hdu 6395Sequence【矩阵快速幂】【分块】

最新推荐文章于 2019-03-17 13:54:13 发布

wybooooooooo

最新推荐文章于 2019-03-17 13:54:13 发布

阅读量190

点赞数

CC 4.0 BY-SA版权

分类专栏： hdu 矩阵快速幂分块

本文链接：https://blog.youkuaiyun.com/wybooooooooo/article/details/81741493

hdu 同时被 3 个专栏收录

18 篇文章

订阅专栏

矩阵快速幂

1 篇文章

订阅专栏

分块

1 篇文章

订阅专栏

本文介绍了一种使用矩阵快速幂优化递推序列计算的方法，适用于求解随机大数值问题。通过构造特定矩阵并利用矩阵快速幂算法，该方法能够在O(logn)的时间复杂度内高效求解递归序列中的第n项，尤其当序列中包含分段常数项时，此方法的优势更为明显。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Sequence

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others)
Total Submission(s): 1951 Accepted Submission(s): 750

Problem Description

Let us define a sequence as below

⎧⎩⎨⎪⎪⎪⎪⎪⎪F1F2Fn===ABC⋅Fn−2+D⋅Fn−1+⌊Pn⌋

Your job is simple, for each task, you should output Fn module 109+7.

Input

The first line has only one integer T, indicates the number of tasks.

Then, for the next T lines, each line consists of 6 integers, A , B, C, D, P, n.

1≤T≤200≤A,B,C,D≤1091≤P,n≤109

Sample Input

2 3 3 2 1 3 5 3 2 2 2 1 4

Sample Output

36 24

Source

2018 Multi-University Training Contest 7

Recommend

chendu | We have carefully selected several similar problems for you: 6408 6407 6406 6405 6404

学习了一个新的递推求数的方法

通过构造矩阵用矩阵递推用矩阵快速幂优化可以用来求一个随机的很大的数的值

矩阵快速幂的写法 O(logn)

这道题还有一点特别的是后面的常数项是会变化的但是他是分段的

所以就分块的来求因为要知道乘的次数所以每次要求一下这个区间有多少个数

c++TLE g++AC


#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<stack>
#define inf 1e18
using namespace std;

long long t, a, b, c, d, p, n;
const int mod = 1e9 + 7;
struct mat{
    long long m[3][3];
    mat(){
        memset(m, 0, sizeof(m));
    }
    void init()
    {
        memset(m, 0, sizeof(m));
        for(int i = 0; i < 3; i++){
            m[i][i] = 1;
        }
    }
    friend mat operator * (mat a, mat b)
    {
        mat c;
        for(int i = 0; i < 3; i++){
            for(int j = 0; j < 3; j++){
                for(int k = 0; k < 3; k++){
                    c.m[i][j] += a.m[i][k] * b.m[k][j];
                    c.m[i][j] %= mod;
                }
            }
        }
        return c;
    }
};

mat pow_mat(mat a, int b)
{
    mat c;
    c.init();
    while(b){
        if(b & 1){
            c = c * a;
        }
        a = a * a;
        b >>= 1;
    }
    return c;
}

int main()
{
    scanf("%lld", &t);
    while(t--){
        scanf("%lld%lld%lld%lld%lld%lld", &a, &b, &c, &d, &p, &n);
        if(n == 1){
            printf("%lld\n", a);
            continue;
        }
        mat f;
        f.m[0][0] = d;
        f.m[1][0] = c;
        f.m[2][0] = f.m[0][1] = f.m[2][2] = 1;
        mat g;
        g.m[0][0] = b;
        g.m[0][1] = a;

        if(p >= n){
            for(long long i = 3, j; i <= n; i = j + 1){
                j = p / (p / i);//个数
                g.m[0][2] = p / i;
                mat po = pow_mat(f, min(j - i + 1, n - i + 1));
                g = g * po;
            }
        }
        else{
            for(long long i = 3, j; i <= p; i = j + 1){
                j = p / (p / i);
                g.m[0][2] = p / i;
                mat po = pow_mat(f, j - i + 1);
                g = g * po;
            }
            mat po;
            g.m[0][2] = 0;
            if(p < 3){
                po = pow_mat(f, n - 2);
            }
            else{
                po = pow_mat(f, n - p);
            }
            g = g * po;
        }
        printf("%lld\n", g.m[0][0]);
    }
    return 0;
}