高精度算法

所谓高精度算法，就是把一个大整数的每一位分开储存，分开操作，从而避免溢出。在某些时候，数据可能会大到long long类型都会溢出，这时候就需要用到高精度算法了。其实，高精度算法是比较鸡肋的，很少单独考察，而且通常会被模运算替代，使用次数越来越少。但不排除有些题目就是要用到高精度，比如NOIP2012 国王游戏，而且学习高精度算法可以加深对于加减乘除等基本运算的细节理解，也可以提升一下代码能力。

 

#include <cstring>
#include <iostream>
#include <string>

using namespace std;

struct BigInteger {
    int num[maxn], len, flag; //flag用来表示是否为负数

    BigInteger(long long x = 0) {
        memset(num, 0, sizoef(num)); //切记要初始化！！！
        len = flag = 0;
        for (int i = 1; x; ++i)
            num[i] = x % 10, x /= 10, ++len;
    }

    BigInteger(string s = "0") {
        memset(num, 0, sizeof(num)); //切记要初始化!
        len = s.length(), flag = 0;
        for (int i = 1; i <= len; ++i)
            num[i] = s[len - i] - '0'; //不要忘记减去'0'
    }

    bool operator < (const BigInteger& rhs) const {
        if (len == rhs.len) { //小于运算符可将其他比较运算符表示出来
            for (int i = len; i >= 1; --i)
                if (num[i] != rhs.num[i])
                    return num[i] < rhs.num[i];
            return false;
        }
        else return len < rhs.len;
    }

    void operator + (const BigInteger& rhs) {
        len = max(len, rhs.len);
        for (int i = 1; i <= len; ++i) {
            num[i] += rhs.num[i];
            if (num[i] > 9) { //加法进位
                ++num[i + 1];
                num[i] -= 10;
            }
        }
        if (num[len + 1]) ++len; //更新大整数的位数
    }

    void operator - (BigInteger& rhs) {
        if (*this < rhs)
            swap(*this, rhs), flag = 1; //保证被减数大于减数
        for (int i = 1; i <= len; ++i) {
            num[i] -= rhs.num[i];
            if (num[i] < 0) { //减法借位
                --num[i + 1];
                num[i] += 10;
            }
        }
        while (!num[len] && len > 1)
            --len; //更新位数,注意要加上len>1,否则为0时会出错
    }

    void operator * (const int& rhs) { //高精乘低精
        for (int i = 1; i <= len; ++i)
            num[i] *= rhs; //先每位乘上再处理进位
        for (int i = 1; i <= len; ++i)
            for (int j = i; num[j] > 9; ++j) {
                num[j + 1] += num[j] / 10;
                num[j] %= 10;
            }
        len += 15; //因为新增加的位数不超过15
        while (!num[len] && len > 1) --len;
    }

    void operator * (const BigInteger& rhs) { //高精乘高精
        BigInteger ans = BigInteger(0);
        for (int i = 1; i <= len; ++i) //列成竖式再观察,会有此规律
            for (int j = 1; j <= rhs.len; ++j) {
                ans.num[i + j - 1] += num[i] * rhs.num[j];
                if (ans.num[i + j - 1] > 9) {
                    ans.num[i + j] += ans.num[i + j - 1]/10;
                    ans.num[i + j - 1] %= 10;
                }
            }
        ans.len = len + rhs.len;
        //一个a位数和一个b位数相乘,结果最多为a+b位数
        while (!ans.num[ans.len] && ans.len > 1) --ans.len;
        *this = ans;
    }

    void operator / (const int& rhs) { //高精除以低精
        for (int i = len; i >= 1; --i) {
            num[i - 1] += num[i] % rhs * 10;
            num[i] /= rhs;
        }
        num[0] /= 10; //num[0]保存余数
        while (!num[len] && len > 1) --len;
    }

    BigInteger operator / (BigInteger& rhs) { //高精除以高精
        BigInteger ans = BigInteger(0);
        //返回商,原来的BigInteger保存余数
        while (!(*this < rhs)) { //连续的减法模拟除法
            *this - rhs;
            ans + BigInteger("1");
        }
        return ans;
    }

    void print() {
        if (flag) cout << "-";
        for (int i = len; i >= 1;--i) cout << num[i];
    }
};