自己写的好挫的大数。。。。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#define LL long long
#define s2 (sqrt(2))
using namespace std;

struct big_int
{
    int v[1000];
    int len;
    big_int()
    {
        memset(v,sizeof(v));
        len=0;
    }
    void mem(int b)
    {
        if(b<0) exit(-1);
        len=0;
        while(b)
        {
            v[len++]=b%10;
            b/=10;
        }
    }
    void mem(const char *s)
    {
        len=0;
        int ls=strlen(s);
        while(ls>0 && s[0]=='0')
        {
            ls--;
            s++;
        }
        while(len<ls)
        {
            v[len]=s[ls-len-1]-'0';
            if(v[len]<0 || v[len]>9) exit(-2);
            len++;
        }
    }
    void print(const char *c="",const char *s="")
    {
        printf("%s",c);
        if(len==0)
        {
            printf("0%s",s);
            return;
        }
        for(int i=len-1;i>=0;i--)
        {
            printf("%d",v[i]);
        }
        printf("%s",s);
    }
};


big_int operator+(big_int a,big_int b)
{
    big_int ans;
    int c=0,la=0,lb=0;
    while(la<a.len && lb<b.len)
    {
        c=a.v[la]+b.v[lb]+c;
        ans.v[ans.len++]=c%10;
        c=c/10;
        la++;lb++;
    }
    while(la<a.len)
    {
        c=a.v[la]+c;
        ans.v[ans.len++]=c%10;
        c=c/10;
        la++;
    }
    while(lb<b.len)
    {
        c=b.v[lb]+c;
        ans.v[ans.len++]=c%10;
        c=c/10;
        lb++;
    }
    while(c)
    {
        ans.v[ans.len++]=c%10;
        c=c/10;
    }
    return ans;
}

big_int exp(int a,int n)
{
    big_int ans;
    ans.len=n+1;
    ans.v[n]=a;
    return ans;
}

big_int exp(big_int a,int n)
{
    big_int ans;
    ans.len=max(0,a.len+n);
    memcpy(ans.v+n,a.v,a.len*sizeof(int));
    return ans;
}

big_int operator*(big_int a,int b)
{
    big_int ans;
    if(a.len==0 || b==0)
    {
        ans.mem(0);
        return ans;
    }
    int c=0,lb=0;
    while(la<a.len || c>0)
    {
        c=a.v[la]*b+c;
        ans.v[ans.len++]=c%10;
        c=c/10;
        la++;
    }
    return ans;
}

big_int operator*(int a,big_int b)
{
    return b*a;
}

big_int operator*(big_int a,big_int b)
{
    big_int ans;
    if(a.len==0 || b.len==0)
    {
        return ans;
    }
    int len;
    for(len=0;len<b.len;len++)
    {
        ans=ans+exp(a*b.v[len],len);
    }
    return ans;
}

big_int operator^(big_int a,int b)
{
    big_int ans,t=a;
    ans.mem(1);
    while(b)
    {
        if(b&1) ans=ans*t;
        t=t*t;
        b>>=1;
    }
    return ans;
}
big_int operator^(big_int a,big_int b)
{
    big_int ans,t=a;
    ans.mem(1);
    while(b.len)
    {
        ans=ans*(t^b.v[0]);
        t=t^10;
        b=exp(b,-1);
    }
    return ans;
}

int main()
{
    return 0;
}

后来又写了一个好一点的：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
using namespace std;
typedef long long LL;
const LL M=1000000000LL;
const int maxlen=3;
class bint
{
    public:
    int len;
    LL a[maxlen];

    bint(LL x);
    void print(char *);
    void println();
    bint left_move(int);
    bint operator+(bint);
    bint operator*(bint);
    bint operator*(LL);
    bint operator/(LL);
};
/**********************************/
bint::bint(LL x=0)
{
    len=0;
    //memset(a,sizeof(a));
    while(x)
    {
        len++;
        a[len-1]=x%M;
        x/=M;
    }
}

/*
2
1000000000000
Case 1: 177532966574642659861022
*/

void bint::print(char *s="")
{
    //printf("len=%dn",len);
    if(len==0)
    {
        printf("0%s",s);
        return;
    }
    printf("%I64d",a[len-1]);
    for(int i=len-2;i>=0;i--) printf("%09I64d",a[i]);
    printf("%s",s);
}

void bint::println(){print("n");}

bint bint::left_move(int t=1)
{
    if(len==0 || t<=0) return *this;
    len+=t;
    //if(len>=maxlen) exit(-1);
    for(int i=len-1;i>=t;i--) a[i]=a[i-t];
    for(int i=t-1;i>=0;i--) a[i]=0;
    return *this;
}

bint bint::operator+(bint t)
{
    bint ans=t;
    LL c=0;
    LL alen=max(len,ans.len);
    for(int i=0;i<alen;i++)
    {
        //ans.println();
        if(ans.len<=i)
        {
            ans.len++;
            ans.a[i]=0;
        }
        if(len<=i) ans.a[i]+=c;
        else ans.a[i]+=a[i]+c;
        c=ans.a[i]/M;
        if(c) ans.a[i]%=M;
    }
    if(c)
    {
        ans.len++;
        ans.a[ans.len-1]=c;
    }
    return ans;
}

bint bint::operator*(LL t)
{
    if(t>=M) return (*this) * bint(t);
    bint ans=*this;
    LL c=0;
    for(int i=0;i<len;i++)
    {
        ans.a[i]*=t;
        ans.a[i]+=c;
        c=ans.a[i]/M;
        if(c) ans.a[i]%=M;
        //ans.println();
    }
    if(c)
    {
        ans.len++;
        ans.a[ans.len-1]=c;
    }
    return ans;
}

bint bint::operator*(bint t)
{
    bint ans(0);
    for(int i=0;i<len;i++)
    {
        ans=ans+(t*a[i]).left_move(i);
        //ans.println();
    }
    return ans;
}

bint bint::operator/(LL t)
{
    bint ans=*this;
    LL r=0;
    for(int i=len-1;i>=0;i--)
    {
        ans.a[i]=(a[i]+r*M)/t;
        r=(a[i]+r*M)%t;
        //ans.println();
    }
    if(ans.a[len-1]==0) ans.len--;
    return ans;
}

/**********************************/


int main()
{
    int T;
    int cas=1;
    scanf("%Id",&T);
    while(T--)
    {
        LL n,m,i,j;
        bint ans(0);
        LL a,b;
        scanf("%I64d",&n);
        m=sqrt(n+0.5);
        for(i=1;i<=m;i++)
        {
            a=n/i;
            b=n/(i+1)+1;
            ans=ans+bint(a-b+1)*(n%a+n%b);
        }
        ans=ans/2;
        for(i=2;i<b;i++) ans=ans+bint(n%i);
        printf("Case %d: ",cas++);
        ans.println();
        //printf("%I64dn",bl(n));
    }
    return 0;
}