HDU5351大数模板加斐波那契

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <climits>
#include <cassert>
#define LL long long
#define lson lo, mi, rt << 1
#define rson mi + 1, hi, rt << 1 | 1

using namespace std;
const int maxn = 1000 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double ee = exp(1.0);

const int mod = 258280327;

struct huge
{
#define N_huge 850
#define base 100000000
static char s[N_huge*10];
typedef long long value;
value a[N_huge];
int len;
void clear()
{
len=1;
a[len]=0;
}
huge()
{
clear();
}
huge(value x)
{
*this=x;
}
huge operator =(huge b)
{
len=b.len;
for (int i=1; i<=len; ++i)a[i]=b.a[i];
return *this;
}
huge operator +(huge b)
{
int L=len>b.len?len:b.len;
huge tmp;
for (int i=1; i<=L+1; ++i)tmp.a[i]=0;
for (int i=1; i<=L; ++i)
{
if (i>len)tmp.a[i]+=b.a[i];
else if (i>b.len)tmp.a[i]+=a[i];
else
{
tmp.a[i]+=a[i]+b.a[i];
if (tmp.a[i]>=base)
{
tmp.a[i]-=base;
++tmp.a[i+1];
}
}
}
if (tmp.a[L+1])tmp.len=L+1;
else tmp.len=L;
return tmp;
}
huge operator -(huge b)
{
int L=len>b.len?len:b.len;
huge tmp;
for (int i=1; i<=L+1; ++i)tmp.a[i]=0;
for (int i=1; i<=L; ++i)
{
if (i>b.len)b.a[i]=0;
tmp.a[i]+=a[i]-b.a[i];
if (tmp.a[i]<0)
{
tmp.a[i]+=base;
--tmp.a[i+1];
}
}
while (L>1&&!tmp.a[L])--L;
tmp.len=L;
return tmp;
}
huge operator *(huge b)
{
int L=len+b.len;
huge tmp;
for (int i=1; i<=L; ++i)tmp.a[i]=0;
for (int i=1; i<=len; ++i)
for (int j=1; j<=b.len; ++j)
{
tmp.a[i+j-1]+=a[i]*b.a[j];
if (tmp.a[i+j-1]>=base)
{
tmp.a[i+j]+=tmp.a[i+j-1]/base;
tmp.a[i+j-1]%=base;
}
}
tmp.len=len+b.len;
while (tmp.len>1&&!tmp.a[tmp.len])--tmp.len;
return tmp;
}
pair<huge,huge> divide(huge a,huge b)
{
int L=a.len;
huge c,d;
for (int i=L; i; --i)
{
c.a[i]=0;
d=d*base;
d.a[1]=a.a[i];
//while (d>=b){d-=b;++c.a[i];}
int l=0,r=base-1,mid;
while (l<r)
{
mid=(l+r+1)>>1;
if (b*mid<=d)l=mid;
else r=mid-1;
}
c.a[i]=l;
d-=b*l;
}
while (L>1&&!c.a[L])--L;
c.len=L;
return make_pair(c,d);
}
huge operator /(value x)
{
value d=0;
huge tmp;
for (int i=len; i; --i)
{
d=d*base+a[i];
tmp.a[i]=d/x;
d%=x;
}
tmp.len=len;
while (tmp.len>1&&!tmp.a[tmp.len])--tmp.len;
return tmp;
}
value operator %(value x)
{
value d=0;
for (int i=len; i; --i)d=(d*base+a[i])%x;
return d;
}
huge operator /(huge b)
{
return divide(*this,b).first;
}
huge operator %(huge b)
{
return divide(*this,b).second;
}
huge &operator +=(huge b)
{
*this=*this+b;
return *this;
}
huge &operator -=(huge b)
{
*this=*this-b;
return *this;
}
huge &operator *=(huge b)
{
*this=*this*b;
return *this;
}
huge &operator ++()
{
huge T;
T=1;
*this=*this+T;
return *this;
}
huge &operator --()
{
huge T;
T=1;
*this=*this-T;
return *this;
}
huge operator ++(int)
{
huge T,tmp=*this;
T=1;
*this=*this+T;
return tmp;
}
huge operator --(int)
{
huge T,tmp=*this;
T=1;
*this=*this-T;
return tmp;
}
huge operator +(value x)
{
huge T;
T=x;
return *this+T;
}
huge operator -(value x)
{
huge T;
T=x;
return *this-T;
}
huge operator *(value x)
{
huge T;
T=x;
return *this*T;
}
//huge operator /(value x){huge T;T=x;return *this/T;}
//huge operator %(value x){huge T;T=x;return *this%T;}
huge operator *=(value x)
{
*this=*this*x;
return *this;
}
huge operator +=(value x)
{
*this=*this+x;
return *this;
}
huge operator -=(value x)
{
*this=*this-x;
return *this;
}
huge operator /=(value x)
{
*this=*this/x;
return *this;
}
huge operator %=(value x)
{
*this=*this%x;
return *this;
}
bool operator ==(value x)
{
huge T;
T=x;
return *this==T;
}
bool operator !=(value x)
{
huge T;
T=x;
return *this!=T;
}
bool operator <=(value x)
{
huge T;
T=x;
return *this<=T;
}
bool operator >=(value x)
{
huge T;
T=x;
return *this>=T;
}
bool operator <(value x)
{
huge T;
T=x;
return *this<T;
}
bool operator >(value x)
{
huge T;
T=x;
return *this>T;
}
huge operator =(value x)
{
len=0;
while (x)a[++len]=x%base,x/=base;
if (!len)a[++len]=0;
return *this;
}
bool operator <(huge b)
{
if (len<b.len)return 1;
if (len>b.len)return 0;
for (int i=len; i; --i)
{
if (a[i]<b.a[i])return 1;
if (a[i]>b.a[i])return 0;
}
return 0;
}
bool operator ==(huge b)
{
if (len!=b.len)return 0;
for (int i=len; i; --i)
if (a[i]!=b.a[i])return 0;
return 1;
}
bool operator !=(huge b)
{
return !(*this==b);
}
bool operator >(huge b)
{
return !(*this<b||*this==b);
}
bool operator <=(huge b)
{
return (*this<b)||(*this==b);
}
bool operator >=(huge b)
{
return (*this>b)||(*this==b);
}
huge str(char s[])
{
int l=strlen(s);
value x=0,y=1;
len=0;
for (int i=l-1; i>=0; --i)
{
x=x+(s[i]-'0')*y;
y*=10;
if (y==base)a[++len]=x,x=0,y=1;
}
if (!len||x)a[++len]=x;
}
void read()
{
scanf("%s",s);
this->str(s);
}
void print()
{
printf("%d",(int)a[len]);
for (int i=len-1; i; --i)
{
for (int j=base/10; j>=10; j/=10)
{
if (a[i]<j)printf("0");
else break;
}
printf("%d",(int)a[i]);
}
printf("\n");
}
};
char huge::s[N_huge*10];

huge fib[maxn];

void init()
{
fib[1] = 1;
fib[2] = 1;
for (int i = 3; i < maxn; i++)
{
fib[i] = fib[i - 1] + fib[i - 2];
}
}

int main()
{
#ifdef LOCAL
freopen("in.txt", "r", stdin);
#endif // LOCAL
init();
int ncase;
scanf("%d", &ncase);
while (ncase--)
{
int n;
scanf("%d", &n);
huge m;
m.read();
if (m == 1 || m == 2)
{
printf("0\n");
continue;
}
int i;
for (i = 2; i < n + 2; i++)
{
if (m + 1 < fib[i])
break;
}
m = m - fib[i - 2];
m %= mod;
m.print();
}
return 0;
}