算是一道水题把(虽然我还是WA了很多次)
还是高精度,但这次的数据范围有点大,都已经有两千多位数了,用每个单元放4位数字,貌似后来试了一下还是可以放得下,也是能AC的
我刚开始怕不够,就用每个单元放8位数字,就是把高精度模板里的DLEN改成8 但是刚开始忘了把相应的MAXN改成99999999,所以WA了
每个单元存放8位数字,用a[256]就足够了,然后因为最多2005位,则最大的数也就是10的2005次方,所以开到f[8000]就足够了
AC代码如下:
#include<iostream>
#include<string>
#include<iomanip>
#include<algorithm>
#include<cstring>
using namespace std;
#define MAXN 99999999
#define DLEN 8
class BigNum
{
private:
int a[256]; //可以控制大数的位数
int len; //大数长度
public:
BigNum(){ len = 1;memset(a,0,sizeof(a)); } //构造函数
BigNum(const int); //将一个int类型的变量转化为大数
BigNum(const BigNum &); //拷贝构造函数
BigNum &operator=(const BigNum &); //重载赋值运算符,大数之间进行赋值运算
BigNum operator+(const BigNum &) const; //重载加法运算符,两个大数之间的相加运算
void print(); //输出大数
};
BigNum::BigNum(const int b) //将一个int类型的变量转化为大数
{
int c,d = b;
len = 0;
memset(a,0,sizeof(a));
while(d > MAXN)
{
c = d - (d / (MAXN + 1)) * (MAXN + 1);
d = d / (MAXN + 1);
a[len++] = c;
}
a[len++] = d;
}
BigNum::BigNum(const BigNum & T) : len(T.len) //拷贝构造函数
{
int i;
memset(a,0,sizeof(a));
for(i = 0 ; i < len ; i++)
a[i] = T.a[i];
}
BigNum & BigNum::operator=(const BigNum & n) //重载赋值运算符,大数之间进行赋值运算
{
int i;
len = n.len;
memset(a,0,sizeof(a));
for(i = 0 ; i < len ; i++)
a[i] = n.a[i];
return *this;
}
BigNum BigNum::operator+(const BigNum & T) const //两个大数之间的相加运算
{
BigNum t(*this);
int i,big; //位数
big = T.len > len ? T.len : len;
for(i = 0 ; i < big ; i++)
{
t.a[i] +=T.a[i];
if(t.a[i] > MAXN)
{
t.a[i + 1]++;
t.a[i] -=MAXN+1;
}
}
if(t.a[big] != 0)
t.len = big + 1;
else
t.len = big;
return t;
}
void BigNum::print() //输出大数
{
int i;
cout << a[len - 1];
for(i = len - 2 ; i >= 0 ; i--)
{
cout.width(DLEN);
cout.fill('0');
cout << a[i];
}
cout << endl;
}
int main()
{
int n;
BigNum f[8001];
f[1]=f[2]=f[3]=f[4]=BigNum(1);
for(int i=5;i<=8000;i++)
f[i]=f[i-1]+f[i-2]+f[i-3]+f[i-4];
while(scanf("%d",&n)!=EOF){
f[n].print();
}
return 0;
}