高精模板

我肝了好多天啊！！！！

终于把高精的模板搞出来了！！！

这个高精是直接用结构体封装的，然后可以很方便的直接声明高精变量，然后就可以像普通的高精一样使用了

现有如下三个版本

Code1：

不支持负数

struct HP {
    int p[25555], len;//array max are 25555
    bool flag;
    HP () {
        memset(p, 0, sizeof p);
        len = 1, flag = false;
    }
    void in() {
        len = 0;
        char c = getchar();
        while (c < '0' || c > '9'){if (c == '-') flag ^= 1; c = getchar();}
        while ('0' <= c && c <= '9') {p[++len] = c - '0'; c = getchar();}
        for (int l = 1, r = len; l < r;) {
            swap(p[l++], p[r--]);
        }
    }
    void make(int x) {
        memset(p, 0, sizeof p);
        len = 0;
        while (x) {
            p[++len] = x;
            x /= 10;
        }
    }
    void print() {
        if (flag == true) printf("-");
        for (int i = len; i >= 1; i--) {
            printf("%d", p[i]);
        }
    }
    bool operator < (const HP &b) const {
        if(len != b.len) return len < b.len;
        for (int i = len; i >= 1; i--) {
            if(p[i] != b.p[i]) return p[i] < b.p[i];
        }
        return false;
    }
    bool operator > (const HP &b) const {
        if(len != b.len) return len > b.len;
        for (int i = len; i >= 1; i--) {
            if(p[i] != b.p[i]) return p[i] > b.p[i];
        }
        return false;
    }
    bool operator <= (const HP &b) const {
        if (len != b.len) return len < b.len;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return p[i] < b.p[i];
        }
        return true;
    }
    bool operator >= (const HP &b) const {
        if (len != b.len) return len > b.len;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return p[i] > b.p[i];
        }
        return true;
    }
    bool operator == (const HP &b) const {
        if (len != b.len) return false;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return false;
        }
        return true;
    }
    bool operator != (const HP &b) const {
        if (len != b.len) return true;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return true;
        }
        return false;
    }
    HP operator + (const HP &b) const {//high + high
        HP c;
        c.len = max(len, b.len);
        int re = 0;
        for (int i = 1; i <= c.len; i++) {
            re += p[i] + b.p[i];
            c.p[i] = re % 10;
            re /= 10;
        }
        while (re) {
            c.p[++c.len] = re % 10;
            re /= 10;
        }
        return c;
    }
    HP operator - (const HP &B) const {//high - high
        HP a = (*this), b = B, c;
        if (a < b) {c.flag = true; swap(a, b);}
        c.len = a.len;
        int re = 0;
        for (int i = 1; i <= c.len; i++) {
            re += a.p[i] - b.p[i];
            if (re < 0) {
                c.p[i] = re + 10;
                re = -1;
            } else {
                c.p[i] = re;
                re = 0;
            }
        }
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    HP operator * (const int &B) const {//high * low
        if (B == 1) return (*this);
        int b = B;
        HP c;
        c.len = len;
        int re = 0;
        for (int i = 1; i <= len; i++) {
            re += p[i] * b;
            c.p[i] = re % 10;
            re /= 10;
        }
        while (re) {
            c.p[++c.len] = re % 10;
            re /= 10;
        }
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    HP operator * (const HP &b) const {//high * high
        if (b.len == 1 && b.p[1] == 1) return (*this);
        if (len == 1 && p[1] == 1) return b;
        HP c;
        c.len = len + b.len;
        for (int i = 1; i <= len; i++) {
            int re = 0;
            for (int j = 1; j <= b.len; j++) {
                c.p[i + j - 1] += p[i] * b.p[j] + re;
                re = c.p[i + j - 1] / 10;
                c.p[i + j - 1] %= 10;
            }
            c.p[i + b.len] = re;
        }
        while (c.p[c.len] > 0) c.len++;
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    HP operator / (const int &b) const {//high / low
        if (b == 1) return (*this);
        HP c;
        c.len = len;
        int re = 0;
        for (int i = len; i >= 1; i--) {
            re = re * 10 + p[i];
            c.p[i] = re / b;
            re %= b;
        }
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    bool div_cmp(const HP& b) {//a compoent of high / high
        if (len < b.len) return true;
        for (int i = 0; i < b.len; i++) {
            if (p[len - i] != b.p[b.len - i]) {
                return p[len - i] < b.p[b.len - i];
            }
        }
        return false;
    }
    HP div_mul(int t) {//a compoent of high / high
        if (!t) return (*this);
        HP c;
        c.len = len + t;
        for (int i = 1; i <= len; i++) {
            c.p[i + t] = p[i];
        }
        return c;
    }
    HP operator / (HP b) const {//high / high
        if (b.len == 1 && b.p[1] == 1) return (*this);
        if ((*this) < b) {
            HP c;
            c.len = 1, c.p[1] = 0;
            return c;
        }
        HP a = (*this), c, tmp;
        c.len = -1;
        int l, t;
        while (true) {
            l = a.len - b.len - a.div_cmp(b);
            if (l < 0) break;
            tmp = b.div_mul(l);
            t = 0;
            while (tmp <= a) {
                a = a - tmp;
                t++;
            }
            if (c.len == -1 && t) {
                c.len = l + 1;
            }
            c.p[l + 1] = t;
        }
        return c;
    }
    HP operator % (const int b) const {//high % low
        HP d = (*this), c = (*this) / b;
        c = c * b;
        HP e = d - c;
        return e;
    }
    HP operator % (const HP &b) const {//high % high
        HP d = (*this), c = (*this) / b;
        c = c * b;
        HP e = d - c;
        return e;
    }
};
HP pw(HP x, HP y) {
    HP re = e1;//need to declare a variable as 1
    for (; y > e0; y = y / 2) {
        if (y % 2 == e1) {
            re = re * x;
        }
        x = x * x;
    }
    return re;
}
HP Max(const HP &a, const HP &b) {
    if (a.len > b.len) {
        return a;
    } else if (a.len < b.len) {
        return b;
    }
    for (int i = a.len; i >= 1; i--) {
        if (a.p[i] > b.p[i]) {
            return a;
        } else if (a.p[i] < b.p[i]) {
            return b;
        }
    }
    return a;
}
HP Min(const HP &a, const HP &b) {
    if (a.len > b.len) {
        return b;
    } else if (a.len < b.len) {
        return a;
    }
    for (int i = a.len; i >= 1; i--) {
        if (a.p[i] < b.p[i]) {
            return a;
        } else if (a.p[i] > b.p[i]) {
            return b;
        }
    }
    return a;
}

Code2：

支持负数

struct HP {
    int p[25555], len;//看题目开数组,最大就25555 
    bool flag;
    HP () {
        memset(p, 0, sizeof p);
        len = 0, flag = false;
    }
    void in() {
        char c = getchar();
        while (c < '0' || c > '9'){if (c == '-') flag ^= 1; c = getchar();}
        while ('0' <= c && c <= '9') {p[++len] = c - '0'; c = getchar();}
        for (int l = 1, r = len; l < r;) {
            swap(p[l++], p[r--]);
        }
    }
    void print() {
        if (flag == true) printf("-");
        for (int i = len; i >= 1; i--) {
            printf("%d", p[i]);
        }
    }
    bool operator < (const HP &b) const {//高精之间的比较 支持负数 
        if (flag && !b.flag) return true;
        if (!flag && b.flag) return false;
        if (flag && b.flag) {
            if(len != b.len) return len > b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] > b.p[i];
            }
            return false;
        } else {
            if(len != b.len) return len < b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] < b.p[i];
            }
            return false;
        }
    }
   bool operator > (const HP &b) const {
        if (flag && !b.flag) return false;
        if (!flag && b.flag) return true;
        if (flag && b.flag) {
            if(len != b.len) return len < b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] < b.p[i];
            }
            return false;
        } else {
            if(len != b.len) return len > b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] > b.p[i];
            }
            return false;
        }
    }
    bool operator <= (const HP &b) const {
        if (flag && !b.flag) return true;
        if (!flag && b.flag) return false;
        if (flag && b.flag) {
            if(len != b.len) return len > b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] > b.p[i];
            }
            return true;
        } else {
            if(len != b.len) return len < b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] < b.p[i];
            }
            return true;
        }
    }
    bool operator >= (const HP &b) const {
        if (flag && !b.flag) return false;
        if (!flag && b.flag) return true;
        if (flag && b.flag) {
            if(len != b.len) return len < b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] < b.p[i];
            }
            return true;
        } else {
            if(len != b.len) return len > b.len;
            for (int i = len; i >= 1; i--) {
                if(p[i] != b.p[i]) return p[i] > b.p[i];
            }
            return true;
        }
    }
    bool operator == (const HP &b) const {
        if (flag ^ b.flag) return false;
        if (len != b.len) return false;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return false;
        }
        return true;
    }
    bool operator != (const HP &b) const {
        if (flag ^ b.flag) return true;
        if (len != b.len) return true;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return true;
        }
        return false;
    }
    HP operator + (const HP &B) const {//高精 + 高精 支持负数 
        HP b = B;
        if (!flag && b.flag) {
            b.flag = false;
            return (*this) - b;
        }
        if (flag && !b.flag) {
            HP a = (*this);
            a.flag = false;
            return b - a;
        }
        if (flag && B.flag) {
            HP a = (*this), c;
            a.flag = b.flag = false;
            c = a + b;
            c.flag = true;
            return c;
        }
        HP c;
        c.len = max(len, b.len);
        int re = 0;
        for (int i = 1; i <= c.len; i++) {
            re += p[i] + b.p[i];
            c.p[i] = re % 10;
            re /= 10;
        }
        while (re) {
            c.p[++c.len] = re % 10;
            re /= 10;
        }
        return c;
    }
    HP operator - (const HP &B) const {//高精 - 高精 支持负数 
        if (!flag && B.flag) {
            HP b = B;
            b.flag = false;
            return (*this + b);
        }
        if (flag && !B.flag) {
            HP a = (*this), c;
            a.flag = false;
            c = a + B;
            c.flag = false;
            return c;
        }
        if (flag && B.flag) {
            HP a = (*this), b = B, c;
            if (a < b) {
                a.flag = b.flag = false;
                c = a - b;
                c.flag = true;
                return c;
            } else {
                a.flag = b.flag = false;
                c = b - a;
                return c;
            }
        }
        HP a = (*this), b = B, c;
        if (a < b) {c.flag = true; swap(a, b);}
        c.len = a.len;
        int re = 0;
        for (int i = 1; i <= c.len; i++) {
            re += a.p[i] - b.p[i];
            if (re < 0) {
                c.p[i] = re + 10;
                re = -1;
            } else {
                c.p[i] = re;
                re = 0;
            }
        }
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    HP operator * (const int &B) const {//高精 * 单精 支持负数 
        if (B == 1) return (*this);
        int b = B;
        HP c;
        if (B < 0) {
            b = -B;
            c.flag = true;
        }
        if (flag) c.flag = true;
        c.len = len;
        int re = 0;
        for (int i = 1; i <= len; i++) {
            re += p[i] * b;
            c.p[i] = re % 10;
            re /= 10;
        }
        while (re) {
            c.p[++c.len] = re % 10;
            re /= 10;
        }
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    HP operator * (const HP &b) const {//高精 * 高精 支持负数 
        if (b.len == 1 && b.p[1] == 1 && !b.flag) return (*this);
        if (len == 1 && p[1] == 1 && !flag) return b;
        HP c;
        if (flag || b.flag) {
            c.flag = flag ^ b.flag;
        }
        c.len = len + b.len;
        for (int i = 1; i <= len; i++) {
            int re = 0;
            for (int j = 1; j <= b.len; j++) {
                c.p[i + j - 1] += p[i] * b.p[j] + re;
                re = c.p[i + j - 1] / 10;
                c.p[i + j - 1] %= 10;
            }
            c.p[i + b.len] = re;
        }
        while (c.p[c.len] > 0) c.len++;
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    HP operator / (const int &b) const {//高精 / 单精 
        if (b == 1) return (*this);
        HP c;
        c.len = len;
        int re = 0;
        for (int i = len; i >= 1; i--) {
            re = re * 10 + p[i];
            c.p[i] = re / b;
            re %= b;
        }
        while (c.len > 1 && c.p[c.len] == 0) c.len--;
        return c;
    }
    bool div_cmp(const HP& b) {//用于优化高精 / 高精 
        if (len < b.len) return true;
        for (int i = 0; i < b.len; i++) {
            if (p[len - i] != b.p[b.len - i]) {
                return p[len - i] < b.p[b.len - i];
            }
        }
        return false;
    }
    HP div_mul(int t) {//用于优化高精 / 高精 
        if (!t) return (*this);
        HP c;
        c.len = len + t;
        for (int i = 1; i <= len; i++) {
            c.p[i + t] = p[i];
        }
        return c;
    }
    HP operator / (HP b) const {//高精 / 高精 不支持负数 
        if (b.len == 1 && b.p[1] == 1) return (*this);
        if ((*this) < b) {
            HP c;
            c.len = 1, c.p[1] = 0;
            return c;
        }
        HP a = (*this), c, tmp;
        c.len = -1;
        int l, t;
        while (true) {
            l = a.len - b.len - a.div_cmp(b);
            if (l < 0) break;
            tmp = b.div_mul(l);
            t = 0;
            while (tmp <= a) {
                a = a - tmp;
                t++;
            }
            if (c.len == -1 && t) {
                c.len = l + 1;
            }
            c.p[l + 1] = t;
        }
        return c;
    }
    HP operator % (const int b) const {//高精 % 单精 不支持负数
        HP d = (*this), c = (*this) / b;
        c = c * b;
        HP e = d - c;
        return e;
    }
    HP operator % (const HP &b) const {//高精 % 高精 不支持负数
        HP d = (*this), c = (*this) / b;
        c = c * b;
        HP e = d - c;
        return e;
    }
};
HP Max(const HP &a, const HP &b) {//高精max 不支持负数 
    if (a.len > b.len) {
        return a;
    } else if (a.len < b.len) {
        return b;
    }
    for (int i = a.len; i >= 1; i--) {
        if (a.p[i] > b.p[i]) {
            return a;
        } else if (a.p[i] < b.p[i]) {
            return b;
        }
    }
    return a;
}
HP Min(const HP &a, const HP &b) {//高精min 不支持负数 
    if (a.len > b.len) {
        return b;
    } else if (a.len < b.len) {
        return a;
    }
    for (int i = a.len; i >= 1; i--) {
        if (a.p[i] < b.p[i]) {
            return a;
        } else if (a.p[i] > b.p[i]) {
            return b;
        }
    }
    return a;
}

Code2：

压4位高精，不带除法

const int power = 4;
const int Base = 1e4;
struct HP {
    int p[10001], len;
    bool flag;
    HP () {
        len = 1, memset(p, 0, sizeof p);
    }
    void in() {
        int a[10000007], cnt = 0;
        char ch = getchar();
        while (ch < '0' || ch > '9') {ch = getchar();}
        while ('0' <= ch && ch <= '9') {a[cnt++] = ch - '0'; ch = getchar();}
        for (int l = 0, r = cnt - 1; l < r;) {
            swap(a[l++], a[r--]);
        }
        memset(p, 0, sizeof 0);
        len = (cnt + power - 1) / power;
        for (int i = 0, t = 0, w; i < cnt; i++, w *= 10) {
            if (i % power == 0) w = 1, t++;
            p[t] += w * a[i];
        }
    }
    void make(int x) {
        int a[10000007], cnt = 0;
        while (x) a[cnt++] = x % 10, x /= 10;
        memset(p, 0, sizeof 0);
        len = (cnt + power - 1) / power;
        for (int i = 0, t = 0, w; i < cnt; i++, w *= 10) {
            if (i % power == 0) w = 1, t++;
            p[t] += w * a[i];
        }
    }
    void print() {
        printf("%d", p[len]);
        for (int i = len - 1; i >= 1; i--) {
            printf("%.4d", p[i]);
        }
        puts("");
    }
    void add(int x) {
        if (x || len) p[++len] = x;
    }
    void rev() {
        reverse(p + 1, p + 1 + len);
    }
    bool operator >= (const HP &b) const {
        if (len != b.len) return len > b.len;
        for (int i = len; i >= 1; i--) {
            if (p[i] != b.p[i]) return p[i] > b.p[i];
        }
        return true;
    }
    HP operator + (const HP &b) {
        HP c;
        c.len = max(len, b.len);
        int re = 0;
        for (int i = 1; i <= c.len; i++) {
            c.p[i] = p[i] + b.p[i] + re;
            re = c.p[i] / Base;
            c.p[i] %= Base;
        }
        while (re) c.p[++c.len] = re, re /= Base;
        return c;
    }
    HP operator - (const HP &b) {
        HP c = *(this);
        for (int i = 1; i <= c.len; i++) {
            c.p[i] -= b.p[i];
            if (c.p[i] < 0) {
                c.p[i] += Base;
                c.p[i + 1]--;
            }
        }
        while (c.len && !c.p[c.len]) c.len--;
        return c;
    }
    HP operator * (const int &b) {
        HP c;
        c.len = len;
        int re = 0;
        for (int i = 1; i <= c.len; i++) {
            c.p[i] = p[i] * b + re;
            re = c.p[i] / Base;
            c.p[i] %= Base;
        }
        while (re) c.p[++c.len] = re % Base, re /= Base;
        return c;
    }
    HP operator * (const HP &b) {
        HP c;
        c.len = len + b.len - 1;
        for (int i = 1; i <= len; i++) {
            for (int j = 1; j <= b.len; j++) {
                c.p[i + j - 1] += p[i] * b.p[j];
                c.p[i + j] += c.p[i + j - 1] / Base;
                c.p[i + j - 1] %= Base;
            }
        }
        while (c.p[c.len + 1]) c.len++;
        return c;
    }
};

当然，我也不太敢保证完全无锅，但是我觉得差不多（逃