C++实现大整数阶乘

已于 2023-06-13 14:31:32 修改
阅读量2.8k 收藏 20
点赞数 6
文章标签： c++ 开发语言 算法 数据结构
于 2023-05-26 11:54:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jtouzjw/article/details/130882906
版权

目录

题目

一.常规做法

二.高精度大数实现——O（N^2）

三.自定义Integer类大整数实现——O（NlogNlogN）

四.Integer类代码

题目

        原题：求10000以内阶乘

        想法:

                最近自己刚好在尝试实现c++的大整数类，刚好拿来实验一下大整数的计算

                大整数：实现了加,减,乘,除和一些简单的赋值操作

                后面介绍一些注意点！

一.常规做法

实现:        

        最常规做法就是，使用迭代的方法，用1*2*3*4...n。

代码:

#include <iostream>
using namespace std;

int main()
{
    int n;
    cin >> n;
    long long sum = 1;
    for (int i = 1; i <= n; i++)
    {
        sum *= i;
    }
    cout << sum << endl;
}

输入:

10

输出：

3628800

        但是这里出现问题了，n大于一定数量会爆longlong。所以需要我们实现一个大数操作。

二.高精度大数实现——O（N^2）

        我们这里模仿了正常的乘法的实现过程，使用vector来实现大数的乘法。

#pragma GCC optimize(2)

#include <iostream>
#include <vector>
#include <time.h>
using namespace std;

vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;

    int t = 0;
    for (int i = 0; i < A.size() || t; i++)
    {
        if (i < A.size())
            t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0)
        C.pop_back();

    return C;
}

void fac(int n)
{
    vector<int> sum;
    sum.push_back(1);
    for (int i = 1; i <= n; i++)
    {
        sum = mul(sum, i);
    }
    // 输出结果
    for (int i = sum.size() - 1; i >= 0; i--)
    {
        cout << sum[i];
    }
    cout << endl;
}

int main()
{

    clock_t start, end; // 定义clock_t变量

    int n;
    cin >> n;

    start = clock(); // 开始时间

    fac(n);

    end = clock(); // 结束时间

    cout << "running time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;
}

输入:

100

输出：

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
running time = 0.005s

 当输入更大的时候：

n=100    running time = 0.005s
n=1000   running time = 0.032s
n=10000  running time = 2.357s
n=50000  running time = 66.046s

分析：

        我们发现当n增大的时候,时间增大的也很快。

       这种乘法是由一个位数很大的数(vector存储)和一个位数很小的数相乘完成的，每一位相乘就         是一次运算。大数的位数是O（N）量级。小数位数虽然可以看为常数级但是一共有n个，所         以也是O（N）量级。总的复杂度就是O（N^{2}）。

        从上面时间也可以看出实际上增大会更大。

三.自定义Integer类大整数实现——O（NlogNlogN）

思路： 

      时间花费这么多，怎么能忍！！

        我们换种方法来计算，让阶乘的计算过程想一颗树一样会怎么样。

        看下面n=8的过程：

                1 * 2   3 * 4    5 * 6   7 *  8 
                2    *   12       30   *  56
                24          *      1680
                40320

        让相邻两个数相乘，是不是logN轮就结束啦。

        但是现在问题来了，我们变成了两个大数相乘了，从上文知道大数是O（N）量级。

        两个也就是O（N^{2}），再乘上logN轮，变成了O（N^{2}logN）。坏了，更慢了？

        先不急，我们考虑大数相乘的优化。分治法O(n^1.59)，使用NTT算法O(nlogn)！

        这不就是O（Nlog^{2}N）复杂度了嘛！

代码：

#pragma GCC optimize(2)

#include <iostream>
#include <queue>
#include <time.h>
#include "Integer.h" //自己实现的类直接导入.h文件就好啦 代码再下面
using namespace std;

int fac(int n)
{
	if (n == 0)
	{
		cout << n << "!=" << 1 << endl;
		return 0;
	}
	Integer *A = new Integer[n + 1];
	// 给每个对象赋值
	for (int i = 1; i <= n; i++)
	{
		A[i] = i;
	}
	// 用分治的方法来计算(可以多线程)
	// 每次乘法为O(nlogn) 然后分治为O(logn) 总的复杂度为O(nlogn*logn) 十万以内几秒吧
	for (int i = 1; i <= n; i *= 2)
	{
		for (int j = 1; j <= n; j += 2 * i)
		{
			if (j + i <= n)
			{
				A[j] = A[j] * A[j + i];
				A[j + i].clear();
			}
		}
	}
	// 结果
	if (A[1].size() > 10)
	{
		cout << "the number have " << A[1].size() << " digit" << endl;
		cout << "output?[Y/N]\n";
		string a;
		cin >> a;
		if (a[0] == 'Y')
			cout << n << "!=" << A[1] << endl;
	}
	else
	{
		cout << n << "!=" << A[1] << endl;
	}
	delete[] A;
	return 0;
}

int main()
{

	clock_t start, end; // 定义clock_t变量

	int n; // cin >> n;
	cin >> n;

	start = clock(); // 开始时间
	fac(n);
	end = clock(); // 结束时间

	cout << "running time = " << double(end - start) / CLOCKS_PER_SEC << "s" << endl;

	return 0;
}

输入：

100

输出：

the number have 158 digit
output?[Y/N]
Y
100!=93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
running time = 0.009s

当输入更大的时候：

使用了NTT的算法                          未使用的O（N^2）算法
n=100    running time = 0.002s          n=100    running time = 0.005s
n=1000   running time = 0.007s          n=1000   running time = 0.032s
n=10000  running time = 0.067s          n=10000  running time = 2.357s
n=50000  running time = 0.577s          n=50000  running time = 66.046s
n=100000 running time = 1.269s         
n=500000 running time = 7.973s

效果还是挺挺显著的，看上来也基本符合O（Nlog^{2}N）复杂度。

四.Integer类代码

注意点:

        实现的类的代码有点长，主要是因为乘法用了NTT来实现，总的来说效果不错O(nlogn)的算法比分治法O(n^1.59)好不少。

        除法是使用了牛顿迭代法也是O(nlogn)。问题是，这个除法内存占得有点多，可能用一万次就要爆内存，大概因为我代码写的有点问题。有时间我在加上普通的除法吧让两种算法取舍一下。 

        加法和减法正常实现O(n)，然后可以用longlong类型来赋值并且cout可以直接输出。

        实现了一些比较。

测试代码:

#include <iostream>
#include "Integer.h" //自己实现的类直接导入.h文件就好啦 代码再下面
using namespace std;

int main()
{
    Integer a, b;
    a = 23424234;
    b = 267678;
    cout << a << endl;
    cout << "加:" << a - b << endl; // 减
    cout << "减:" << a + b << endl; // 加
    cout << "乘:" << a * b << endl; // 乘
    cout << "除:" << a / b << endl; // 除
    cout << "余" << a % b << endl;  // 余
    // 常见比较
    if (a / b * b + a % b == a)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
    // 大于
    if (a > b)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
    // 小于
    if (a < b)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
    return 0;
}

结果:

加:23156556
减:23691912
乘:6270152108652
除:87
余136248
YES
YES
NO

最后:

        在一些平台测试过数据，但不保证完全正确，有bug欢迎大家来跟我交流和指正，谢谢大家观看。

使用:

        新建一个Integer.h文件，然后复制粘贴下面代码就可以使用啦。

        遇到头文件出问题网上应该都有解决方案。

Integer.h代码 :

#ifndef BigInteger
#define BigInteger

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <math.h>

class Poly_div
{
public:
    struct complex
    {
        double a, b;
        complex() : a(0), b(0) {}
        complex(double x, double y) : a(x), b(y) {}
        void operator+=(const complex& z) { a += z.a, b += z.b; }
        complex operator-(const complex& z) { return { a - z.a, b - z.b }; }
        complex operator*(const complex& z) { return { a * z.a - b * z.b, a * z.b + b * z.a }; }
    };
    const long long Mod = 998244353;
    long long L;

    complex* W[2];
    int* a, * b, * bi, * x, * y, * rev;
    complex* t1, * t2;
    long long* t3;
    int n, m, d;

    // 构造函数
    Poly_div(long long num)
    {
        L = num;
        rev = new int[L << 1]();
        W[0] = new complex[L]();
        W[1] = new complex[L]();
        a = new int[L]();
        b = new int[L]();
        bi = new int[L]();
        x = new int[L]();
        y = new int[L]();
        t1 = new complex[L]();
        t2 = new complex[L]();
        t3 = new long long[L + 1]();
        n = 0;
        m = 0;
        d = 0;
    }
    ~Poly_div()
    {
        delete[] rev;
        delete[] W[0];
        delete[] W[1];
        delete[] a;
        delete[] b;
        delete[] bi;
        delete[] x;
        delete[] y;
        delete[] t1;
        delete[] t2;
        delete[] t3;
    }
    // 得到函数
    void get(std::vector<int>& A, std::vector<int>& B)
    { // A B都是规范化之后的
        n = A.size();
        for (int i = 0; i < A.size(); i++)
        {
            a[A.size() - 1 - i] = A[i];
        }
        m = B.size();
        for (int i = 0; i < B.size(); i++)
        {
            b[B.size() - 1 - i] = B[i];
        }
    }
    // 除法
    void div(std::vector<int>& A)
    {
        FFT_Init();
        d = divide(n, m);
        lack(n, m, d);
        for (int i = 0; i < n + m; i++)
        {
            A.push_back(x[i]);
        }
        return;
    }

    // 初始化
    void FFT_Init()
    {

        int i, j;
        const int l = L >> 1;
        const double pi = acos(-1);
        for (i = j = 1; j < L; j <<= 1)
            for (; i < j << 1; i++)
                rev[i << 1] = rev[i], rev[i << 1 | 1] = rev[i] + j;
        for (i = 0; i < l; i++)
            W[0][i + l] = { cos(pi * i / l), sin(pi * i / l) };
        for (i = l - 1; i; i--)
            W[0][i] = W[0][i << 1];

        memcpy(W[1], W[0], L * sizeof(complex));
        for (i = 1; i < L; i++)
            W[1][i].b *= -1;
    }
    // 过程
    void FFT(complex* f, int len, int sign)
    {
        int i = 1, j, k;
        complex* p, * q, * w, t;
        t.a = 0;
        t.b = 0;
        sign = (int)(sign < 0);
        for (int* r = rev + len + 1; i < len; i++, r++)
            if (i < (k = *r))
                t = f[i], f[i] = f[k], f[k] = t;

        for (i = 1; i < len; i <<= 1)
            for (j = 0; j < len; j += i, j += i)
                for (q = (p = f + j) + i, w = W[sign] + i, k = 0; k < i; k++, p++, q++)
                    t = *q * *w++, * q = *p - t, * p += t;

        if (sign)
        {
            double p = 1. / len;
            for (i = 0; i < len; i++, f++)
                f->a *= p, f->b *= p;
        }
    }

    void majutsu(int len) // 计算b的倒数，有效位数为len，结果存进bi里
    {

        bool g = 1;
        int l = 16, l2 = 32, l4 = 64, i;
        long double d = 0, e = 1;
        for (i = 0; i < 20; i++)
        {
            d = d + e * b[i], e *= 0.1;
        }
        d = 10. / d;

        if (d < 10)
        {
            for (i = 0; i <= l; i++)
                bi[i] = d, d = (d - bi[i]) * 10;
            bi[l - 1] += (bi[l] > 4);
        }
        else
            bi[0] = 10;

        while (l < len)
        {
        p:
            memset(t1, 0, sizeof(complex) * l4);
            memset(t2, 0, sizeof(complex) * l4);
            for (i = 0; i < l2; i++)
                t1[i].a = b[i];
            for (i = 0; i < l; i++)
                t2[i].a = bi[i];
            FFT(t1, l4, 1), FFT(t2, l4, 1);

            for (i = 0; i < l4; i++)
            {
                t1[i] = t1[i] * t2[i];
                t1[i].a = 20 - t1[i].a, t1[i].b = -t1[i].b;
                t2[i] = t1[i] * t2[i];
            }

            FFT(t2, l4, -1);
            t3[l4] = 0;

            for (i = l4 - 1; i >= 0; i--)
            {
                t3[i] = (long long)(floor(t2[i].a + 0.5)) + t3[i + 1] / 10, t3[i + 1] %= 10;
                if (t3[i + 1] < 0)
                    t3[i + 1] += 10, t3[i]--;
            }
            if (t3[0] > 9)
            {
                bi[0] = t3[0] / 10, t3[0] %= 10;
                for (i = 1; i < l2; i++)
                    bi[i] = t3[i - 1];
                bi[l2 - 1] += (t3[l2 - 1] > 4);
            }
            else
            {
                for (i = 0; i < l2; i++)
                    bi[i] = t3[i];
                bi[l2 - 1] += (t3[l2] > 4);
            }
            l <<= 1, l2 <<= 1, l4 <<= 1;
        }

        if (g)
        {
            g = 0, l >>= 1, l2 >>= 1, l4 >>= 1;
            goto p;
        } // 迭代过程结束后末几位仍会有偏差，于是再单独迭代一次
    }
    int divide(int n, int m) // 计算a/b，整数部分存进x里
    {
        int p = n - m + 16, l, i;
        majutsu(p);
        for (l = 1; l < n + p; l <<= 1)
            ;
        memset(t1, 0, sizeof(complex) * l);
        memset(t2, 0, sizeof(complex) * l);
        for (i = 0; i < n; i++)
            t1[i].a = a[i];
        for (i = 0; i < p; i++)
            t2[i].a = bi[i];
        FFT(t1, l, 1), FFT(t2, l, 1);
        for (i = 0; i < l; i++)
            t1[i] = t1[i] * t2[i];
        FFT(t1, l, -1);
        t3[l] = 0;
        for (i = l - 1; i >= 0; i--)
            t3[i] = (long long)(t1[i].a + 0.5) + t3[i + 1] / 10, t3[i + 1] %= 10;
        if (t3[0] > 9)
        {
            x[0] = t3[0] / 10, t3[0] %= 10, l = n - m + 1;
            for (i = 0; i < n - m; i++)
                x[i + 1] = t3[i];
        }
        else
            for (l = n - m, i = 0; i < n - m; i++)
                x[i] = t3[i];
        return l;
    }
    void lack(int n, int m, int& d) // 微调
    {
        int l, i, j;
        char t;
        long long tl = 0;
        for (i = 0, j = n - 1; i < j; i++, j--)
            t = a[i], a[i] = a[j], a[j] = t;
        for (i = 0, j = m - 1; i < j; i++, j--)
            t = b[i], b[i] = b[j], b[j] = t;
        for (i = 0, j = d - 1; i < j; i++, j--)
            t = x[i], x[i] = x[j], x[j] = t;
        for (l = 1; l < n; l <<= 1)
            ;
        memset(t1, 0, sizeof(complex) * l);
        memset(t2, 0, sizeof(complex) * l);
        for (i = 0; i < m; i++)
            t1[i].a = b[i];
        for (i = 0; i < d; i++)
            t2[i].a = x[i];
        t2[0].a += 1.;
        FFT(t1, l, 1), FFT(t2, l, 1);
        for (i = 0; i < l; i++)
            t1[i] = t1[i] * t2[i];
        FFT(t1, l, -1);
        for (i = 0; i <= n; i++)
            tl += (long long)(t1[i].a + 0.5), y[i] = tl % 10, tl /= 10;
        for (i = n; i >= 0; i--)
        {
            if (y[i] > a[i])
                return;
            else if (y[i] < a[i])
                break;
        }
        for (x[0]++, i = 0; x[i] > 9; i++)
            x[i + 1] += x[i] / 10, x[i] %= 10;
        if (x[d])
            d++;
    }
};

class Polynomial
{
public:
    long long Mod = 998244353;
    int G = 3, iG = 332748118;
    int MS;
    long long* Inv; // 逆元
    long long Sz, * R;
    long long InvSz; //	NTT
    int N, M;
    long long* A1, * B1;

    Polynomial(int sum)
    {
        MS = std::max(64, sum * 2);
        Inv = new long long[MS];
        R = new long long[MS];
        A1 = new long long[MS];
        B1 = new long long[MS];

        for (int i = 0; i < MS; i++)
        {
            Inv[i] = 0;
            R[i] = 0;
            A1[i] = 0;
            B1[i] = 0;
        }
        InvSz = 0;
        Sz = 0;
        N = 0;
        M = 0;
        Init(MS);
    }

    void get(std::vector<int>& A, std::vector<int>& B);
    std::vector<int>& add();
    std::vector<int>& sub();
    std::vector<int>& mul();
    static int cmp(std::vector<int>& A, std::vector<int>& B);

    void Clear();
    long long qPow(long long b, int e);
    void Init(int N);
    void InitFNTT(int N);
    void FNTT(long long* A, int Ty);
    void PolyMul(long long* A, long long* B, int deg);
    void PolyInv(long long* A, int N, long long* B);
    void PolyLn(long long* A, int N, long long* B);
    void PolyExp(long long* A, int N, long long* B);
};

class Integer
{

protected:
    std::vector<int> data;
    int flag = 1;

public:
    Integer();
    Integer(long long a);
    Integer(int flag, std::vector<int>& a);

    void check();
    friend std::istream& operator>>(std::istream& in, Integer& a);
    friend std::ostream& operator<<(std::ostream& out, Integer& a);
    long long abs(long long a);
    Integer& operator=(Integer& a);
    Integer& operator=(long long a);
    Integer& operator=(std::string& a);
    int operator==(long long a);
    int operator==(Integer& a);
    int operator!=(long long a);
    int operator!=(Integer& a);
    int operator<(Integer& a);
    int operator<=(Integer& a);
    int operator>(Integer& a);
    int operator>=(Integer& a);
    Integer& operator+(Integer& a);
    Integer& operator-(Integer& a);
    Integer& operator-();
    Integer& operator/(Integer& a);
    Integer& operator%(Integer& a);
    Integer& operator*(Integer& a);
    std::vector<int>& Polymul_tool(std::vector<int> a, std::vector<int> b);
    int size() { return data.size(); }
    void clear()
    {
        flag = 1;
        data.clear();
        data.push_back(0);
    }
};
long long Integer::abs(long long a)
{
    if (a < 0)
        return -a;
    else
        return a;
}

Integer::Integer()
{
    flag = 1;
    data.push_back(0);
}

Integer::Integer(long long a)
{
    if (a < 0)
        flag = -1;
    else
        flag = 1;
    a = abs(a);
    while (a)
    {
        data.push_back(a % 10);
        a /= 10;
    }
}

Integer::Integer(int flag, std::vector<int>& a)
{
    data = a;
    this->flag = 1;
}

int Integer::operator<(Integer& a)
{
    if (flag == 1) {
        if (a.flag == 1) {
            if (Polynomial::cmp(data, a.data) < 0)
                return 1;
            else
                return 0;
        }
        else
        {
            return 0;
        }
    }
    else {
        if (a.flag == 1) {
            return 1;
        }
        else {
            if (Polynomial::cmp(data, a.data) > 0)
                return 1;
            else
                return 0;
        }
    }
    return 0;
}

int Integer::operator<=(Integer& a)
{
    if (flag == 1) {
        if (a.flag == 1) {
            if (Polynomial::cmp(data, a.data) > 0)
                return 0;
            else
                return 1;
        }
        else
        {
            return 0;
        }
    }
    else {
        if (a.flag == 1) {
            return 1;
        }
        else {
            if (Polynomial::cmp(data, a.data) < 0)
                return 0;
            else
                return 1;
        }
    }
    return 0;
}

int Integer::operator>(Integer& a)
{
    if (flag == 1) {
        if (a.flag == 1) {
            if (Polynomial::cmp(data, a.data) > 0)
                return 1;
            else
                return 0;
        }
        else
        {
            return 1;
        }
    }
    else {
        if (a.flag == 1) {
            return 0;
        }
        else {
            if (Polynomial::cmp(data, a.data) < 0)
                return 1;
            else
                return 0;
        }
    }
    return 0;
}

int Integer::operator>=(Integer& a)
{
    if (flag == 1) {
        if (a.flag == 1) {
            if (Polynomial::cmp(data, a.data) < 0)
                return 0;
            else
                return 1;
        }
        else
        {
            return 1;
        }
    }
    else {
        if (a.flag == 1) {
            return 0;
        }
        else {
            if (Polynomial::cmp(data, a.data) > 0)
                return 0;
            else
                return 1;
        }
    }
    return 0;
}

void Integer::check()
{
    for (int i = data.size() - 1; i >= 1; i--)
        if (data[i] == 0)
            data.pop_back();
        else
            break;

    if (data.size() == 1 && data[0] == 0)
        flag = 1;
    if (data.size() == 0)
    {
        data.push_back(0);
        flag = 1;
    }
}

int Integer::operator==(long long a)
{
    Integer tool(a);
    return (*this) == tool;
}

int Integer::operator==(Integer& a)
{
    if (Polynomial::cmp(data, a.data) == 0)
        return 1;
    else
        return 0;
}

int Integer::operator!=(long long a)
{
    if ((*this) == a)
        return 0;
    else
        return 1;
}

int Integer::operator!=(Integer& a)
{
    if ((*this) == a)
        return 0;
    else
        return 1;
}

Integer& Integer::operator=(long long a)
{
    if (a < 0)
        flag = -1;
    else
        flag = 1;
    a = abs(a);
    data.clear();
    while (a)
    {
        data.push_back(a % 10);
        a /= 10;
    }
    return (*this);
}

Integer& Integer::operator=(std::string& date)
{

    if (date[0] == '-')
    {
        flag = -1;
        for (int i = date.size() - 1; i >= 1; i--)
        {
            data.push_back(date[i] - 48);
        }
    }
    else
    {
        flag = 1;
        data.clear();
        for (int i = date.size() - 1; i >= 0; i--)
        {
            data.push_back(date[i] - 48);
        }
    }
    check();
    return *this;
}

Integer& Integer::operator=(Integer& a)
{
    data = a.data;
    flag = a.flag;
    return *this;
}

Integer& Integer::operator+(Integer& a)
{
    if (flag == 1 && a.flag == 1)
    {
        Integer* p;
        p = new Integer;
        p->flag = 1;
        Polynomial poly(data.size() + a.data.size() - 1);
        poly.get(data, a.data);
        p->data = poly.add();
        p->check();
        return (*p);
    }
    else if (flag == -1 && a.flag == -1)
    {
        Integer* p;
        p = new Integer;
        p->flag = -1;
        Polynomial poly(data.size() + a.data.size() - 1);
        poly.get(data, a.data);
        p->data = poly.add();
        p->check();
        return (*p);
    }
    else if (flag == 1 && a.flag == -1)
    {
        Integer b = a;
        b.flag = 1;
        return (*this) - b;
    }
    else if (flag == -1 && a.flag == 1)
    {
        Integer b = (*this);
        b.flag = 1;
        return a - b;
    }
    return a;
}

Integer& Integer::operator-(Integer& a)
{
    if (flag == 1 && a.flag == 1)
    {
        Integer* p;
        p = new Integer;
        Polynomial poly(data.size() + a.data.size() - 1);
        p->flag = poly.cmp(this->data, a.data);
        if (p->flag == 1)
        {
            poly.get(data, a.data);
            p->data = poly.sub();
            return (*p);
        }
        else
        {
            poly.get(a.data, data);
            p->data = poly.sub();
            return (*p);
        }
    }
    else if (flag == -1 && a.flag == -1)
    {
        Integer* p;
        p = new Integer;
        Polynomial poly(data.size() + a.data.size() - 1);
        p->flag = poly.cmp(this->data, a.data);
        if (p->flag == 1)
        {
            poly.get(data, a.data);
            p->data = poly.sub();
            p->flag *= -1;
            return (*p);
        }
        else
        {
            poly.get(a.data, data);
            p->data = poly.sub();
            p->flag *= -1;
            return (*p);
        }
    }
    else
    {
        Integer b = a;
        b.flag *= -1;
        return (*this) + b;
    }
}

Integer& Integer::operator-()
{
    Integer* p;
    p = new Integer;
    p->data.clear();
    p->flag *= -1;
    p->data = data;
    return *p;
}

std::vector<int>& Integer::Polymul_tool(std::vector<int> a, std::vector<int> b)
{

    int deg = a.size() + b.size() - 1;

    for (int i = a.size() - 1; i >= 0; i--)
        if (a[i] == 0)
            a.pop_back();
        else
            break;
    for (int i = b.size() - 1; i >= 0; i--)
        if (b[i] == 0)
            b.pop_back();
        else
            break;

    Polynomial test(a.size() + b.size());
    test.get(a, b);
    std::vector<int>* c;
    c = &test.mul();

    return *c;
}

Integer& Integer::operator*(Integer& a)
{
    Integer* p;
    p = new Integer;
    p->data.clear();
    p->flag = this->flag * a.flag;

    p->data = Polymul_tool(this->data, a.data);

    return *p;
}

Integer& Integer::operator/(Integer& a)
{

    Integer* p;
    p = new Integer;
    p->data.clear();
    p->flag = this->flag * a.flag;

    int cmp_temp = Polynomial::cmp(data,a.data);
    if (cmp_temp == 0) {
        (*p)=1;
        return (*p);
    }
    else if (cmp_temp == -1) {
        return (*p);
    }

    int len = 64;
    int len_2 = 10 + this->data.size() + a.data.size();

    while (len < len_2)
        len *= 2;
    Poly_div test(len * 2);

    test.get(this->data, a.data);
    test.div(p->data);
    p->check();
    return (*p);
}

Integer& Integer::operator%(Integer& a)
{
    return (*this) - (*this) / a * a;
}

std::istream& operator>>(std::istream& in, Integer& a)
{
    a.data.clear();
    std::string date;
    std::cin >> date;
    if (date[0] == '-')
    {
        a.flag = -1;
        for (int i = date.size() - 1; i >= 1; i--)
        {
            a.data.push_back(date[i] - 48);
        }
    }
    else
    {
        a.flag = 1;
        a.data.clear();
        for (int i = date.size() - 1; i >= 0; i--)
        {
            a.data.push_back(date[i] - 48);
        }
    }
    a.check();
    return in;
}

std::ostream& operator<<(std::ostream& out, Integer& a)
{
    a.check();
    if (a.data.size() == 0)
        out << '0';
    else if (a.flag == 1)
    {
        for (int i = a.data.size() - 1; i >= 0; i--)
            out << a.data[i];
    }
    else
    {
        out << "-";
        for (int i = a.data.size() - 1; i >= 0; i--)
            out << a.data[i];
    }
    return out;
}

// Polynomial的函数
void Polynomial::get(std::vector<int>& A, std::vector<int>& B)
{ // A B都是规范化之后的
    N = A.size();
    for (int i = A.size() - 1; i >= 0; i--)
    {
        A1[i] = A[i];
    }
    M = B.size();
    for (int i = B.size() - 1; i >= 0; i--)
    {
        B1[i] = B[i];
    }
}

int Polynomial::cmp(std::vector<int>& A, std::vector<int>& B)
{

    if (A.size() > B.size())
        return 1;
    else if (A.size() < B.size())
        return -1;
    else
    {
        for (int i = A.size() - 1; i >= 0; i--)
        {
            if (A[i] > B[i])
                return 1;
            else if (A[i] < B[i])
                return -1;
        }
        return 0;
    }
    return 0;
}

std::vector<int>& Polynomial::mul()
{
    std::vector<int>* P;
    P = new std::vector<int>;
    if (N == 0 || M == 0)
    {
        P->push_back(0);
        return (*P);
    }

    PolyMul(A1, B1, N + M - 2);
    long long tool = 0;
    for (int i = 0; i < N + M - 1; i++)
    {
        long long a = tool + (A1[i] + Mod) % Mod;
        P->push_back(a % 10);
        tool = a / 10;
    }
    while (tool)
    {
        P->push_back(tool % 10);
        tool /= 10;
    }
    for (int i = P->size() - 1; i >= 1; i--)
    {
        if ((*P)[i] == 0)
            P->pop_back();
        else
            break;
    }
    Clear();
    return (*P);
}

std::vector<int>& Polynomial::sub()
{
    std::vector<int>* P;
    P = new std::vector<int>;
    if (N == 0 && M == 0)
    {
        P->push_back(0);
        return (*P);
    }
    int tool1 = 0;
    int Z = std::max(N, M);
    for (int i = 0; i < Z; i++)
    {
        int tool2 = A1[i] - B1[i] + tool1;
        if (tool2 >= 0)
        {
            tool1 = 0;
            P->push_back(tool2);
        }
        else
        {
            tool1 = -1;
            P->push_back(10 + tool2);
        }
    }
    for (int i = P->size() - 1; i >= 1; i--)
    {
        if ((*P)[i] == 0)
            P->pop_back();
        else
            break;
    }
    Clear();
    return (*P);
}

std::vector<int>& Polynomial::add()
{
    std::vector<int>* P;
    P = new std::vector<int>;
    if (N == 0 && M == 0)
    {
        P->push_back(0);
        return (*P);
    }
    int tool1 = 0;
    int Z = std::max(N, M);
    for (int i = 0; i < Z; i++)
    {
        int tool2 = A1[i] + B1[i] + tool1;
        P->push_back(tool2 % 10);
        tool1 = tool2 / 10;
    }

    if (tool1 > 0)
    {
        P->push_back(tool1);
    }
    for (int i = P->size() - 1; i >= 1; i--)
    {
        if ((*P)[i] == 0)
            P->pop_back();
        else
            break;
    }
    Clear();
    return (*P);
}

void Polynomial::Clear()
{
    for (int i = 0; i < MS; i++)
    {
        R[i] = 0;
        A1[i] = 0;
        B1[i] = 0;
    }
}

long long Polynomial::qPow(long long b, int e)
{ // 快速幂
    long long a = 1;
    for (; e; e >>= 1, b = b * b % Mod)
        if (e & 1)
            a = a * b % Mod;
    return a;
}

void Polynomial::Init(int N)
{ // 求逆元
    Inv[1] = 1;
    for (int i = 2; i < N; ++i)
        Inv[i] = -(Mod / i) * Inv[Mod % i] % Mod;
    return;
}

void Polynomial::InitFNTT(int N)
{
    int Bt = 0;
    for (; 1 << Bt <= N; ++Bt)
        ;
    if (Sz == (1 << Bt))
        return;
    Sz = 1 << Bt;
    InvSz = -(Mod - 1) / Sz;
    for (int i = 1; i < Sz; ++i)
        R[i] = R[i >> 1] >> 1 | (i & 1) << (Bt - 1);
}

void Polynomial::FNTT(long long* A, int Ty)
{
    for (int i = 0; i < Sz; ++i)
        if (R[i] < i)
            std::swap(A[R[i]], A[i]);
    for (int j = 1, j2 = 2; j < Sz; j <<= 1, j2 <<= 1)
    {
        long long gn = qPow(~Ty ? G : iG, (Mod - 1) / j2), g, X, Y;
        for (int i = 0, k; i < Sz; i += j2)
        {
            for (k = 0, g = 1; k < j; ++k, g = g * gn % Mod)
            {
                X = A[i + k], Y = g * A[i + j + k] % Mod;
                A[i + k] = (X + Y) % Mod, A[i + j + k] = (X - Y) % Mod;
            }
        }
    }
    if (!~Ty)
        for (int i = 0; i < Sz; ++i)
            A[i] = A[i] * InvSz % Mod;
}

void Polynomial::PolyMul(long long* A, long long* B, int deg)
{ // 多项式乘法  A=A*B
    InitFNTT(deg);
    FNTT(A, 1);
    FNTT(B, 1);
    for (int i = 0; i < Sz; i++)
    {
        A[i] = (A[i] * B[i]) % Mod;
    }
    FNTT(A, -1);
    FNTT(B, -1);
}

void Polynomial::PolyInv(long long* A, int N, long long* B)
{ // 多项式求inv 对x^N取mod  A*B=1
    // long long tA[MS], tB[MS];
    long long* tA = new long long[MS];
    long long* tB = new long long[MS];
    B[0] = qPow(A[0], Mod - 2);
    for (int L = 1; L < N; L <<= 1)
    {
        int L2 = L << 1, L4 = L << 2;
        InitFNTT(L4);
        memcpy(tA, A, 8 * L2);
        memset(tA + L2, 0, 8 * (Sz - L2));
        memcpy(tB, B, 8 * L);
        memset(tB + L, 0, 8 * (Sz - L));
        FNTT(tA, 1), FNTT(tB, 1);
        for (int i = 0; i < Sz; ++i)
            tB[i] = (2 - tB[i] * tA[i]) % Mod * tB[i] % Mod;
        FNTT(tB, -1);
        for (int i = 0; i < L2; ++i)
            B[i] = tB[i];
    }
    delete[] tA;
    delete[] tB;
}

void Polynomial::PolyLn(long long* A, int N, long long* B)
{ // 多项式求ln 对x^N取mod A[0]=1 B=ln(A)
    long long* tA = new long long[MS];
    long long* tB = new long long[MS];
    PolyInv(A, N - 1, tB);
    InitFNTT(N * 2 - 3);
    for (int i = 1; i < N; ++i)
        tA[i - 1] = i * A[i] % Mod;
    memset(tA + N - 1, 0, 8 * (Sz - N + 1));
    memset(tB + N - 1, 0, 8 * (Sz - N + 1));
    FNTT(tA, 1), FNTT(tB, 1);
    for (int i = 0; i < Sz; ++i)
        tA[i] = (long long)tA[i] * tB[i] % Mod;
    FNTT(tA, -1);
    B[0] = 0;

    for (int i = 1; i < N; ++i)
        B[i] = (long long)tA[i - 1] * Inv[i] % Mod;

    delete[] tA;
    delete[] tB;
}

void Polynomial::PolyExp(long long* A, int N, long long* B)
{ // 多项式求exp 对x^N取mod A[0]=0  B=e^A
    long long* tA = new long long[MS];
    long long* tB = new long long[MS];
    B[0] = 1;
    for (int L = 1; L < N; L <<= 1)
    {
        int L2 = L << 1, L4 = L << 2;
        memset(B + L, 0, 8 * (L2 - L));
        PolyLn(B, L2, tB);
        InitFNTT(L4);
        memcpy(tA, B, 8 * L);
        memset(tA + L, 0, 8 * (Sz - L));
        for (int i = 0; i < L2; ++i)
            tB[i] = ((!i) - tB[i] + A[i]) % Mod;
        memset(tB + L2, 0, 8 * (Sz - L2));
        FNTT(tA, 1), FNTT(tB, 1);
        for (int i = 0; i < Sz; ++i)
            tA[i] = tA[i] * tB[i] % Mod;
        FNTT(tA, -1);
        for (int i = 0; i < L2; ++i)
            B[i] = tA[i];
    }
    delete[] tA;
    delete[] tB;
}

#endif // !BigInteger
寒木春
关注
  • 6
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
大整数阶乘 C++
09-26
C++写的大整数结成的程序。众所周知，阶乘运算的增长速度特别快（比2^n的增长速度快），对于较小整数的阶乘运算采用简单的递规算法可以实现，但是对于大整数的乘法（比如1000！），则传统的递规算法就失去了作用。该程序的思路是：1.开辟一个较大的整形数组； 2.数组的每一个元素只保存计算结果中的一位数字，数组索引最小的元素对应计算结果的最小位，依次类推； 3.在计算中，将1-n中的每一个数字都与数组中的每一个数相乘，将与某元素的乘积仍保存在该元素中； 4.在1-n中的每个数字与所有元素做完乘积之后，依次每一个元素中的数字是否超过10（或者radix），若超过，则向前进位；
C++求阶乘四种方法，阶乘和，高精度阶乘
IT OR 考公？
11-30 5419
蓝桥杯oj刷题，求阶乘之和并取余998244353，第一个问题是时间超限，用了近3秒，网上找了很多答案也都超限了
使用C++，实现高精度加减乘除法运算！
Python_enjoy 是一个大帅哥！
02-17 860
在C++中，储存数据是我们一般用int,long long等自带的数据结构来实现。但是如果数据非常非常大，单单使用这些就存不下来了！这时候，我们就要使用高精度计算了高精度计算的原理其实就是模拟我们常用的竖式计算，使用数组存储
n的阶乘高效率算法
03-04
自己写的n阶乘算法 比普通的1*2*..n 的效率要高些 是我们算法老师布置的题目 有兴趣的 可以下载来看看
大数阶乘求法
weixin_34292402的博客
01-04 96
2019独角兽企业重金招聘Python工程师标准>>> ...
10000以内的阶乘（C/C++实现）
weixin_46601559的博客
11-05 831
#include<bits/stdc++.h> using namespace std; vector<int> v; int n; int main() { int n; cin >> n; if(n == 1) cout << '1' << endl; //n为1时，直接打印结果 else { v.push_back(1); //先向向量中插入一个数字 for(int i = 2;.
C++求阶乘的两种方法
09-04
主要介绍了C++求阶乘的两种方法，有需要的朋友可以参考一下
阶乘c++
我是小学生
04-30 4627
描述 阶乘是基斯顿·卡曼于1808年发明的运算符号，一个正整数的阶乘是所有小于及等于该数的正整数的积，并且0的阶乘为1。自然数n的阶乘写作n!，亦即n!=1×2×3×…×n。 输入 一行，包含一个正整数n（1<n≤12）。 输出 一行，一个整数，表示n的阶乘。 输入样例 1 5 输出样例 1 120 代码： #include<iostream> #include<cstdio> #include<cmath> using namespace std; int mai
C++ 求阶乘 四种方法
热门推荐
YIU
12-10 12万+
来总结下求阶乘的各种方法哈。            写在最前：①各个代码只是提供了求阶乘的思路，以便在实际需要时再来编码，代码并不健壮！②各个程序都在1到10内测试正确。              代码一： [cpp] view plain copy #include   using namespace std;      int
C++ 求阶乘
wangcheng_BI的博客
04-23 1万+
阶乘
大整数阶乘
04-20
大整数阶乘，简单的算法，性能可能不是太好
求一个整数的阶乘
09-11
求一个整数的阶乘 啊
C/C++实现的高位阶乘程序
10-24
C/C++实现的高位阶乘程序，能够实现计算机所不能处理的高位阶乘！是递归思想的经典例子！
【C++第三阶段】list容器&排序
最新发布
还有很多需要学习，现在还很菜
04-29 646
以下内容仅为当前认识，可能有不足之处，欢迎讨论！
C 练习实例36 - 求100之内的素数
2401_82561004的博客
04-27 1056
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
《21天学通C++》（第十章）实现继承（1）
立志成为炼丹师？
04-28 253
覆盖是一种极端情况，即派生类中的重载方法会隐藏基类中方法的所有重载版本，导致需要调用时无法调用，示例代码如下。解决方法3：在派生类中，把基类中的方法全部重载一次，并在派生类中就调用基类方法。只要派生类中实现了从基类中继承的函数，且返回值和标值相同，就可以覆盖。如果基类包含重载的构造函数，可以使用初始化列表传递参数。，避免不定义的情况下，随机数值产生影响。解决办法1：使用作用域解析符。解决方法2：在派生类中使用。同样使用作用域解析运算符。在构造一个派生类时，使用作用域解析运算符。若想调用基类中的方法。
C++ Primer (第五版）第八章习题部分答案
weixin_48467622的博客
04-27 1054
C++ Primer (第五版）第八章习题部分答案
手搓顺序表（C语言）
m0_62646213的博客
04-23 765
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
C++相关概念和易错语法（9）（变量的存储、new和delete混用分析）
SGlow0708的博客
04-28 729
我们发现如果这个时候直接去调用operator delete[]、operator delete、delete、free就会导致释放的内存起始位置发生了位移，这就会导致报错，而delete[]就会先从前4个字节开始，先读取个数，然后。注意数组是开辟了空间的，会发生复制操作，就算是常量字符串储存在代码段，也要拷贝过来。如果类没有显式实现析构函数，那么就意味着不会多开辟那4个字节，也就不会报错，这个时候混用不会导致程序崩溃。当我们创建类的数组时，使用new[]，因为使用它可以在开辟空间的时候。
c++求整数n的阶乘
11-04
C++求整数n的阶乘有两种方法：循环和递归。 循环方法代码如下： ```c++ #include #include using namespace std; int jiecheng(int a) { int s=1; while (a>1) { s= s*a; a-=1; } return s; } int main()...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值