高精度模板

高精度模板，留个备份：

#include <cstdio>
#include <cstring>

struct BigNumber
{
    static const long long BASE = 1000000000;
    static const int BASEDIGS = 9;
    
    int ndigs;
    long long *digs;
    
    void init(int n, const long long *d)
    {
        while (n > 0 && d[n - 1] == 0)
            --n;
        ndigs = n;
        digs = new long long[n];
        for (int i = 0; i < n; ++i)
            digs[i] = d[i];
    }
    
    BigNumber(int n, const long long *d)
    {
        init(n, d);
    }
    
    BigNumber operator <<(int sh) const
    {
        int n = sh + ndigs;
        long long d[n];
        for (int i = 0; i < sh; ++i)
            d[i] = 0;
        for (int i = 0; i < ndigs; ++i)
            d[i + sh] = digs[i];
        return BigNumber(n, d);
    }
    
    BigNumber(long long x = 0)
    {
        long long d[2];
        d[0] = x % BASE;
        d[1] = x / BASE;
        init(2, d);
    }
    
    BigNumber(const BigNumber&a)
    {
        init(a.ndigs, a.digs);
    }
    
    BigNumber(const char *s)
    {
        int n = strlen(s), nd = n / BASEDIGS + 1;
        long long d[nd];
        for (int i = 0; i < nd; i++)
        {
            d[i] = 0;
            for (int j = BASEDIGS - 1; j >= 0; j--)
            {
                long long poz = i * BASEDIGS + j;
                if (poz < n) d[i] = 10 * d[i] + s[n - 1 - poz] - '0';
            }
        }
        init(nd, d);
    }
    
    ~BigNumber()
    {
        delete[] digs;
    }
    
    BigNumber &operator =(const BigNumber &a)
    {
        delete[] digs;
        init(a.ndigs, a.digs);
        return *this;
    }

    BigNumber operator +(const BigNumber &a) const
    {
        int n = (ndigs > a.ndigs ? ndigs : a.ndigs) + 1;
        long long d[n];
        for (int i = 0; i < n; i++)
            d[i] = 0;
        for (int i = 0; i < n; i++)
        {
            if (i < ndigs) d[i] += digs[i];
            if (i < a.ndigs) d[i] += a.digs[i];
            if (d[i] >= BASE)
            {
                d[i] -= BASE;
                ++d[i + 1];
            }
        }
        return BigNumber(n, d);
    }
    
    BigNumber &operator +=(const BigNumber &a)
    {
        return *this = *this + a;
    }

    BigNumber operator -(const BigNumber &a) const
    {
        long long d[ndigs];
        for (int i = 0; i < ndigs; i++)
            d[i] = digs[i];
        for (int i = 0; i < ndigs; i++)
        {
            if (i < a.ndigs) d[i] -= a.digs[i];
            if (d[i] < 0)
            {
                d[i] += BASE;
                --d[i + 1];
            }
        }
        return BigNumber(ndigs, d);
    }
    
    BigNumber &operator -=(const BigNumber &a)
    {
        return *this = *this - a;
    }
    
    BigNumber operator *(const BigNumber &a) const
    {
        int n = ndigs + a.ndigs;
        long long d[n];
        for (int i = 0; i < n; i++)
            d[i] = 0;
        for (int i = 0; i < ndigs; i++)
        {
            long long p = 0;
            for (int j = 0; j < a.ndigs; j++)
            {
                long long v = (long long) (digs[i]) * a.digs[j];
                long long v1 = v / BASE, v0 = v % BASE;
                d[i + j] += v0 + p;
                p = v1 + d[i + j] / BASE;
                d[i + j] %= BASE;
            }
            for(int j = i + a.ndigs; p > 0; ++j)
            {
                d[j] += p;
                p = d[j] / BASE;
                d[j] %= BASE;
            }
        }
        return BigNumber(n, d);
    }
    
    BigNumber &operator *=(const BigNumber &a)
    {
        return *this = *this * a;
    }
    
    BigNumber operator /(const BigNumber &a) const
    {
        int n = (ndigs - a.ndigs + 1 > 0 ? ndigs - a.ndigs + 1 : 0);
        long long d[n];
        BigNumber prod;
        for(int i = n - 1; i >= 0; i--)
        {
            long long l = 0, r = BASE - 1;
            while(l < r)
            {
                long long m = (l + r + 1) / 2;
                if (*this < prod + (a * m << i))
                    r = m - 1;
                else l = m;
            }
            prod += a * l << i;
            d[i] = l;
        }
        return BigNumber(n, d);
    }
    
    BigNumber &operator /=(const BigNumber &a)
    {
        return *this = *this / a;
    }
    
    BigNumber operator %(const BigNumber &a) const 
    {
        return *this - *this / a * a;
    }
    
    BigNumber &operator%=(const BigNumber&a) {
        return *this = *this % a;
    }
    
    BigNumber sqrt() const
    {
        int n = (ndigs + 1) / 2;
        long long d[n];
        for (int i = 0; i < n; i++)
            d[i] = 0;
        BigNumber sq;
        for (int i = n - 1; i >= 0; i--)
        {
            BigNumber a(n, d);
            long long l = 0, r = BASE - 1;
            while (l < r) {
                long long m = (l + r + 1) / 2;
                if (*this < sq + (a * 2 * m << i) + (BigNumber(m) * m << 2 * i))
                    r = m - 1;
                else l = m;
            }
            sq += (a * 2 * l << i) + (BigNumber(l) * l << 2 * i);
            d[i] = l;
        }
        return BigNumber(n, d);
    }

    BigNumber operator *(long long x) const
    {
        int n = ndigs + 1;
        long long d[n];
        long long a = 0;
        for (int i = 0; i < ndigs; i++)
        {
            a += digs[i] * x;
            d[i] = a % BASE;
            a /= BASE;
        }
        d[ndigs] = a;
        return BigNumber(n, d);
    }
    
    BigNumber &operator *=(long long x)
    {
        return *this = *this * x;
    }

    BigNumber operator /(long long x) const
    {
        long long d[ndigs];
        long long a = 0;
        for (int i = ndigs - 1; i >= 0; i--)
        {
            a = BASE * a + digs[i];
            d[i] = a / x;
            a %= x;
        }
        return BigNumber(ndigs, d);
    }
    
    BigNumber &operator /=(long long x)
    {
        return *this = *this / x;
    }
    
    long long operator %(long long x) const
    {
        long long a = 0;
        for (int i = ndigs - 1; i >= 0; i--)
        {
            a = BASE * a + digs[i];
            a %= x;
        }
        return a;
    }
    
    bool operator <(const BigNumber &a) const
    {
        if (ndigs < a.ndigs) return true;
        if (ndigs > a.ndigs) return false;
        for(int i = ndigs - 1; i >= 0; i--)
        {
            if (digs[i] < a.digs[i]) return true;
            if (digs[i] > a.digs[i]) return false;
        }
        return false;
    }
    
    bool operator ==(const BigNumber &a) const
    {
        if (ndigs != a.ndigs) return false;
        for (int i = 0; i < ndigs; i++)
        {
            if (digs[i] != a.digs[i])
                return false;
        }
        return true;
    }
    
    bool operator >(const BigNumber &a) const
    {
        return a < *this;
    }
    
    bool operator <=(const BigNumber &a) const
    {
        return !(a < *this);
    }
    
    bool operator >=(const BigNumber &a) const
    {
        return !(*this < a);
    }
    
    bool operator !=(const BigNumber &a) const
    {
        return !(*this == a);
    }

    void write() const
    {
        if (ndigs == 0) printf("0");
        else
        {
            printf("%lld", digs[ndigs - 1]);
            for (int i = ndigs - 2; i >= 0; i--)
                printf("%0*lld", BASEDIGS, digs[i]);
        }
    }
    
    void write(char *buf) const
    {
        if(ndigs == 0) sprintf(buf, "0");
        else
        {
            long long pos = 0;
            pos += sprintf(buf, "%lld", digs[ndigs - 1]);
            for (int i = ndigs - 2; i >= 0; i--)
                pos += sprintf(buf + pos, "%0*lld", BASEDIGS, digs[i]);
        }
    }
};