Brute-force Algorithm(hdu3221)

Brute-force Algorithm

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2740    Accepted Submission(s): 728

Problem Description

Professor Brute is not good at algorithm design. Once he was asked to solve a path finding problem. He worked on it for several days and finally came up with the following algorithm:

Any fool but Brute knows that the function “funny” will be called too many times. Brute wants to investigate the number of times the function will be called, but he is too lazy to do it.

Now your task is to calculate how many times the function “funny” will be called, for the given a, b and n. Because the answer may be too large, you should output the answer module by P.

 

Input

There are multiple test cases. The first line of the input contains an integer T, meaning the number of the test cases.

For each test cases, there are four integers a, b, P and n in a single line.
You can assume that 1≤n≤1000000000, 1≤P≤1000000, 0≤a, b<1000000.

 

Output

For each test case, output the answer with case number in a single line.

 

Sample Input

3

3 4 10 3

4 5 13 5

3 2 19 100

 Sample Output

Case #1: 2

Case #2: 11

Case #3: 12

 思路：a的指数和b的指数是斐波数列，所以按照指数来，然后当指数小于p时直接快速幂，否则矩阵快速幂，加上oula降幂，前面小于p直接快速幂，也保证了后面使用欧拉降幂的条件。

 #include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<queue>
#include<set>
#include<math.h>
using namespace std;
typedef long long LL;
typedef struct node
{
        LL m[4][4];
        node()
        {
                memset(m,0,sizeof(m));
        }
} maxtr;
int f1[1000];
int f2[1000];
maxtr E();
void Init(maxtr *q);
maxtr quick_m(maxtr ans,LL n,LL mod);
LL quick(LL n,LL m,LL mod);
bool prime[1000005];
int aa[1000005];
int oula[1000005];

int main(void)
{
        int T;
        int __ca = 0;
        int i,j;
        int k1,k2;
        f1[2] = 0;
        f1[3] = 1;
        f2[2] = 1;
        f2[3] = 1;
        for(i = 2; i < 1000; i++)
        {
                for(j = i; (i*j) <= 1000000; j++)
                {
                        prime[i*j] = true;
                }
        }
        int cn = 0;
        for(i = 2; i <= 1000000; i++)
        {
                oula[i] =i;
                if(!prime[i])
                        aa[cn++] = i;
        }
        for(i = 0; i < cn; i++)
        {
                for(j = 1; (j*aa[i])<=1000000; j++)
                {
                        oula[j*aa[i]]/=aa[i];
                        oula[j*aa[i]]*=(aa[i]-1);
                }
        }
        for(i = 4;; i++)
        {
                f1[i] = f1[i-1]+f1[i-2];
                if(f1[i] > 1000000)
                {
                        k1 = i;
                        break;
                }
        }
        for(i = 4;; i++)
        {
                f2[i] = f2[i-1] + f2[i-2];
                if(f2[i] > 1000000)
                {
                        k2 = i;
                        break;
                }
        }
        k1=max(k1,k2);
        scanf("%d",&T);
        while(T--)
        {
                __ca++;
                LL n,p,a,b;
                scanf("%lld %lld %lld %lld",&a,&b,&p,&n);
                printf("Case #%d: ",__ca);
                if(n==1)
                {
                        printf("%lld
",a%p);
                }
                else if(n == 2)
                {
                        printf("%lld
",b%p);
                }
                else if(n == 3)
                {
                        printf("%lld
",a*b%p);
                }
                else  if(n<=k1)
                {
                        int x1 = f1[n];
                        int x2 = f2[n];
                        LL ask = quick(a,x1,p);
                        LL ack = quick(b,x2,p);
                        printf("%lld
",ask*ack%p);
                }
                else
                {
                        if(p==1)printf("0
");
                        else
                        {
                                maxtr cc ;
                                Init(&cc);
                                cc = quick_m(cc,n-3,oula[p]);
                                LL xx = cc.m[0][0] +cc.m[0][1];
                                LL yy = cc.m[1][0] + cc.m[1][1];
                                LL ask = quick(a,yy+oula[p],p)*quick(b,xx+oula[p],p)%p;
                                printf("%lld
",ask);
                        }
                }
        }
        return 0;
}
maxtr E()
{
        maxtr e;
        for(int i = 0; i < 4; i++)
        {
                for(int j = 0; j < 4; j++)
                {
                        if(i == j)
                                e.m[i][j] = 1;
                }
        }
        return e;
}
void Init(maxtr *q)
{
        q->m[0][0] = 1;
        q->m[0][1] = 1;
        q->m[1][0] = 1;
        q->m[1][1] = 0;
}
maxtr quick_m(maxtr ans,LL n,LL mod)
{
        int i,j,s;
        maxtr ak = E();
        while(n)
        {
                if(n&1)
                {
                        maxtr c;
                        for(i = 0; i < 2; i++)
                        {
                                for(j = 0; j < 2; j++)
                                {
                                        for(s = 0; s < 2; s++)
                                        {
                                                c.m[i][j] = c.m[i][j] + ans.m[i][s]*ak.m[s][j]%mod;
                                                c.m[i][j]%=mod;
                                        }
                                }
                        }
                        ak = c;
                }
                maxtr d;
                for(i = 0; i < 2; i++)
                {
                        for(j = 0; j < 2; j++)
                        {
                                for(s= 0; s < 2; s++)
                                {
                                        d.m[i][j] = d.m[i][j] + ans.m[i][s]*ans.m[s][j]%mod;
                                        d.m[i][j]%=mod;
                                }
                        }
                }
                ans = d;
                n>>=1;
        }
        return ak;
}
LL quick(LL n,LL m,LL mod)
{
        LL ak = 1;
        while(m)
        {
                if(m&1)
                        ak = ak*n%mod;
                n = n*n%mod;
                m>>=1;
        }
        return ak;
}