f(n) = (A * f(n - 1) + B * f(n - 2)) mod 7.
可以看出几个数学性质
1. A 替换为 A%7 对结果无影响，也就是不管A取何值，只有7种可能
2. B 亦复如是
3. f(n)为周期性函数，因为f(n-1)最多只有7种可能，f(n-2)最多只有7种可能，因此f(n)的周期小于等于49
因此，最快的算法就是建立一个 [7][7][49] 的三维映射表，直接查表就行了，这应该是理论上最快的算法

太数学化不好，退而求其次，只考虑周期不超过49这一点，就可以在49步内直接预测到最终结果

#include <stdio.h>

unsigned foo( unsigned A, unsigned B, unsigned n )
{
    unsigned buf[53] = { 0, 1, 1, (A+B)%7, (A*(A+B)+B)%7 };
    if( n <= 4 )
        return buf[n];
    if( A%7==0 && B%7==0 )
        return 0;

    for( unsigned i=5; i!=n+1; ++i )
    {
        buf[i] = (A*buf[i-1] + B*buf[i-2]) % 7;

        if( buf[i]==buf[4] && buf[i-1]==buf[3] )
            return buf[(n-2)%(i-4)+2];
    }

    return buf[n];
}

int main( void )
{
    for( unsigned A, B, n; scanf("%u%u%u",&A,&B,&n)==3 && !(A==0 && B==0 && n==0); )
        printf( "%u\n", foo(A,B,n) );

    return 0;
}

http://acm.hdu.

设定大数组 比如long long a[]这样的 是不是不符合规定的？

这么多代码 也就是11楼的不超时

10楼的还存在n取值范围的问题

我在10楼代码数组初始化为1的位置错，放到正确位置后超时，受11楼启发，这的确是建立一个周期表的问题，但不是固定以49为周期，周期不固定，但周期是从元素值1,1开始的，所以如下代码通过，速度0ms。

#include<stdio.h>
void main()
{
    int i,j,a,b,n,f[200];
    while(1)
    {
        scanf("%d%d%d",&a,&b,&n);
        if(a>=1&&b<=1000&&n>=1&&n<=100000000)
        {
            f[0]=1;f[1]=1;
            for(i=2;i<200;i++)
            {//建立周期表
                f[i]=(a*f[i-1]+b*f[i-2])%7;
                if(f[i]==1&&f[i-1]==1)break;
            }
            j=n%(i-1);
            if(j==0)j=i-1;
            printf("%d\n",f[j-1]);
        }
        if(!(a||b||n))break;
    }
}

函数递归也轻松实现
正如11楼分析，当a、b值确定后，在不大于49的数据集里必然出现循环(经反复查看循环规律，a=2至6,b=7,14,21时不是在元素值为1，1时循环），所以n%49经过运算就会指向自己循环规律中需要的值，因此可免除数组存储循环数据，下面代码提交通过，时间31ms.
#include<stdio.h>
int seq(int a,int b,int n)
{//函数递归实现
    if(n<3)
        return 1;
    else
        return ((a*seq(a,b,n-1)+b*seq(a,b,n-2))%7);
}
void main()
{
    int a,b,n;
    while(1)
    {
        scanf("%d%d%d",&a,&b,&n);
        if(a>=1&&b<=1000&&n>=1&&n<=100000000)printf("%d\n",seq(a,b,n%49));
        if(!(a|b|n))break;
    }
}