HDU 6395 Sequence 【矩阵快速幂 && 暴力】

任意门：http://acm.hdu.edu.cn/showproblem.php?pid=6395

Sequence

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

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

 

题意概括：

给出 A，B，C，D，P，N；

根据函数：

F(1)=A， F(2)=B,  F(i)=C*F(i-2)+D*F(i-1)+p/i；

求 F( N );

解题思路：

一开始看错题目，以为 p/n 为 一个常数，其实题目里的 n 是变量（即题意里的 i ）；

如果是常数直接构造矩阵，矩阵快速幂跑一波即可，但是这里是是变量。

所以一开始选择了暴力 p/i ；p的范围是 1e9 果断超时。

怎么优化呢？

其实由于整型除法的向下取整，我们可以按 p/i 的种类分成一段一段的，这样大大缩短了暴力区间。

AC code：

 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <cmath>
 #define LL long long
 using namespace std;
 const int MAXN = ;
 const int Mod = 1e9+;
 const int NN = ;
 int N, A, B, C, D, P;
 struct mat
 {
     LL m[MAXN][MAXN];
 }base, ans;

 mat muti(mat a, mat b)
 {
     mat res;
     memset(res.m, , sizeof(res.m));
     for(int i = ; i <= NN; i++)
     for(int j = ; j <= NN; j++){
             if(a.m[i][j]){
                 for(int k = ; k <= NN; k++){
                     res.m[i][k] = (res.m[i][k] + a.m[i][j]*b.m[j][k])%Mod;
                 }
             }
         }

     return res;
 }

 mat qpow(mat a, int n)
 {
     mat res;
     memset(res.m, , sizeof(res.m));
     for(int i = ; i <= NN; i++) res.m[i][i] = ;
     while(n){
         if(n&) res = muti(res, a);
         n>>=;
         a = muti(a, a);
     }
     return res;
 }

 int main()
 {
     int K, T_case;
     scanf("%d", &T_case);
     while(T_case--){
         memset(base.m, , sizeof(base.m));
         memset(ans.m, , sizeof(ans.m));
         scanf("%d %d %d %d %d %d", &A, &B, &C, &D, &P, &N);
         if(N == ){printf("%d\n", A);continue;}
         if(N == ){printf("%d\n", B);continue;}
         else{
             base.m[][] = C;
             base.m[][] = D;
             base.m[][] = ;
             base.m[][] = ;
             base.m[][] = P/;
             ans.m[][] = A;
             ans.m[][] = B;
             ans.m[][] = ;
             int now = , x, len = , lst;
             for(;now <= N; now = lst+){
                 x = P/now;
                 if(x != ) lst = min(P/x, N);
                 else lst = N;
                 len = lst-now+;
                 base.m[][] = x;
                 ans = muti(ans, qpow(base, len));
             }
         }
         printf("%lld\n", ans.m[][]);
     }

     return ;
 }