HDU 6395 Sequence [ 矩阵快速幂 + 分块 ]

题目链接：

2018 Multi-University Training Contest 7 Sequence HDU - 6395

题意概括：

就是给出一个递推公式，求第 n 项的数。

数据范围：

题解分析：

数据量很大，并且当前项是由前面几项推出的，很自然地可以想到可以用矩阵快速幂计算

但这里不是很裸的矩阵快速幂，多了一个不定的常量   

因为该值在一定范围内是不变的，所以在不变的范围内可以用矩阵快速幂来算

关于求各个不变的范围，有两种方法。一个是二分，另外还有一种 O(1) 的方法：

P / (P / i) 可以求出该值的末尾位置，但是该值可能超出 n 的范围，并且当 P / n = 0 时不可运算。因此代码应该为

end = P / i ? min(P / (P / i), n) : n;

比赛的时候智障了，把 mod 写成了 1e9 + 10 , 无限WA。

AC代码：

#include <stdio.h>
#include <memory.h>
#define min(a,b)    (((a) < (b)) ? (a) : (b))
using namespace std;
typedef long long ll;
const int MOD = 1e9+7;
const int MAXN = 3;

struct mat {
    ll c[MAXN][MAXN];
    int m, n;
    mat(int a, int b) : m(a), n(b) {
        memset(c, 0, sizeof(c));
    }
    mat operator * (const mat& temp) {
        mat ans(m, temp.n);
        for (int i = 0; i < m; i ++)
            for (int j = 0; j < temp.n; j ++)
                for (int k = 0; k < n; k ++)
                    ans.c[i][j] = (ans.c[i][j] + c[i][k] * temp.c[k][j] % MOD) % MOD;
        return ans;
    }
};

mat mat_pow(mat M, int n) {
    mat ans(M.m, M.m);
    for (int i = 0; i < M.m; i ++)
        ans.c[i][i] = 1; 
    while (n > 0) {
        if (n & 1) ans = ans * M;
        M = M * M;
        n >>= 1;
    }
    return ans;
}

int main () {
    int T;
    scanf("%d", &T);
    while (T --) {
        int A, B, C, D, P, n;
        scanf("%d%d%d%d%d%d", &A, &B, &C, &D, &P, &n);

        if (n == 1) printf("%d\n", A);
        else if (n == 2) printf("%d\n", B);
        else {
            mat m(3, 3), M(3, 3);
            ll F1 = A, F2 = B, f1, f2;
            int end;
            m.c[0][0] = D; m.c[0][1] = C; m.c[1][0] = 1; m.c[2][2] = 1;
            for (int i = 3; i <= n; i ++) {
                M = m;
                M.c[0][2] = P / i;
                end = P / i ? min(P / (P / i), n) : n;
                M = mat_pow(M, end - i + 1);

                f2 = (M.c[0][0] * F2 % MOD + M.c[0][1] * F1 % MOD + M.c[0][2]) % MOD;
                f1 = (M.c[1][0] * F2 % MOD + M.c[1][1] * F1 % MOD + M.c[1][2]) % MOD;

                F1 = f1;
                F2 = f2;
                i = end;
            }
            printf("%lld\n", F2);
        }
    }
}

 

                                                            Sequence

                       Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 262144/262144 K (Java/Others)

Problem Description

Let us define a sequence as below

Your job is simple, for each task, you should output Fn module +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≤20

0≤A,B,C,D≤

1≤P,n≤

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