大数模板(加减乘除取模开方)

最新推荐文章于 2022-04-03 10:28:18 发布
最新推荐文章于 2022-04-03 10:28:18 发布
阅读量2k 收藏 3
点赞数
分类专栏： 大数 文章标签： 模板 大数 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AcmHonor/article/details/46894619
版权

不带小数的大数：

struct BigInteger
{
    int len;
    int arg[1005];
    BigInteger(int x = 0){
        IntToBigInteger(x);
    }
    BigInteger(char *str){
        CharToBigInteger(str);
    }
    void print()
    {
        for (int i = len - 1; i >= 0; i--){
            cout<<arg[i];
        }
        cout<<endl;
    }
    void CharToBigInteger(char *str)
    {
        len = strlen(str);
        memset(arg, 0, sizeof(arg));
        for (int i = 0; i < len; i++){
            arg[i] = str[len - i - 1] - 48;
        }
        while(len > 0 && arg[len-1] == 0){
            len--;
        }
    }
    void IntToBigInteger(int x)
    {
        len = 0;
        memset(arg, 0, sizeof(arg));
        do{
            arg[len++] = x % 10;
            x = x / 10;
        }while (x);
    }
    friend istream &operator>>(istream &in, BigInteger &w)
    {
        char str[1005];
        in>>str;
        w.CharToBigInteger(str);
        return in;
    }
    friend ostream& operator<<(ostream &out, BigInteger w)
    {
        for (int i = w.len - 1; i >= 0; i--){
            out<<w.arg[i];
        }
        return out;
    }
    friend bool operator==(BigInteger r, BigInteger w)
    {
        if (r.len != w.len) return false;
        int i = r.len - 1;
        while (i >= 0){
            if (r.arg[i] != w.arg[i])
                return false;
            i--;
        }
        return true;
    }
    friend bool operator<=(BigInteger r, BigInteger w)
    {
        if (r.len < w.len) return true;
        else if (w.len < r.len) return false;
        int i = r.len - 1;
        while (i >= 0){
            if (r.arg[i]<w.arg[i])
                return true;
            else if (r.arg[i]>w.arg[i])
                return false;
            i--;
        }
        return true;
    }
    friend bool operator<=(int x, BigInteger w)
    {
        BigInteger r;
        r.IntToBigInteger(x);
        if (r.len < w.len) return true;
        else if (w.len < r.len) return false;
        int i = r.len - 1;
        while (i >= 0){
            if (r.arg[i]<w.arg[i])
                return true;
            else if (r.arg[i]>w.arg[i])
                return false;
            i--;
        }
        return true;
    }
    friend bool operator<(BigInteger r, BigInteger w)
    {
        if (r.len < w.len) return true;
        else if (w.len < r.len) return false;
        int i = r.len - 1;
        while (i >= 0){
            if (r.arg[i]<w.arg[i])
                return true;
            else if (r.arg[i]>w.arg[i])
                return false;
            i--;
        }
        return false;
    }
    friend bool operator<(int x, BigInteger w)
    {
        BigInteger r;
        r.IntToBigInteger(x);
        if (r.len < w.len) return true;
        else if (w.len < r.len)    return false;
        int i = r.len - 1;
        while (i >= 0){
            if (r.arg[i]<w.arg[i])
                return true;
            else if (r.arg[i]>w.arg[i])
                return false;
            i--;
        }
        return false;
    }
    friend BigInteger operator+(int r, BigInteger w){
        w.arg[0] += r;
        int i = 0;
        while (w.arg[i] >= 10){
            w.arg[i + 1] += w.arg[i] / 10;
            w.arg[i] = w.arg[i] % 10;
            i++;
        }
        if(w.arg[i]) i++;
        w.len = i > w.len ? i : w.len;
        return w;
    }
    friend BigInteger operator+(BigInteger w, int r)
    {
        w.arg[0] += r;
        int i = 0;
        while (w.arg[i] >= 10){
            w.arg[i + 1] += w.arg[i] / 10;
            w.arg[i] = w.arg[i] % 10;
            i++;
        }
        if(w.arg[i]) i++;
        w.len = i > w.len ? i : w.len;
        return w;
    }
    friend BigInteger operator+(BigInteger r, BigInteger w)
    {
        int len = r.len > w.len ? r.len : w.len;
        for (int i = 0; i < len; i++){
            if(i < w.len)
                r.arg[i] = r.arg[i] + w.arg[i];
            r.arg[i + 1] += r.arg[i] / 10;
            r.arg[i] = r.arg[i] % 10;
        }
        while (r.arg[len] >= 10){
            r.arg[len + 1] += r.arg[len] / 10;
            r.arg[len] = r.arg[len] % 10;
            len++;
        }
        if(r.arg[len]) len++;
        r.len  = len > r.len ? len : r.len;
        return r;
    }
    friend BigInteger operator-(BigInteger r, BigInteger w)
    {
        for (int i = 0; i < r.len; i++){
            if (r.arg[i] >= w.arg[i])
                r.arg[i] = r.arg[i] - w.arg[i];
            else{
                r.arg[i] = r.arg[i] + 10;
                r.arg[i + 1] = r.arg[i + 1] - 1;
                r.arg[i] = r.arg[i] - w.arg[i];
            }
        }
        while (r.arg[r.len - 1] == 0 && r.len > 1)
            r.len--;
        return r;
    }
    friend BigInteger operator-(BigInteger r, int w)
    {
        for (int i = 0; i < r.len; i++, w = w / 10){
            if (r.arg[i] >= w % 10)
                r.arg[i] = r.arg[i] - w % 10;
            else{
                r.arg[i] = r.arg[i] + 10;
                r.arg[i + 1] = r.arg[i + 1] - 1;
                r.arg[i] = r.arg[i] - w % 10;
            }
        }
        while (r.arg[r.len - 1] == 0 && r.len > 1)
            r.len--;
        return r;
    }
    friend BigInteger operator*(int x, BigInteger w)
    {
        BigInteger r;
        if(x == 0 || (w.len == 1 && w.arg[0] == 0)){
            return r;
        }
        for (int i = 0; i < w.len; i++){
            r.arg[i] += w.arg[i] * x;
            r.arg[i + 1] += r.arg[i] / 10;
            r.arg[i] = r.arg[i] % 10;
        }
        int i = r.arg[w.len] == 0 ? w.len-1 : w.len;
        while (r.arg[i] >= 10){
            r.arg[i + 1] = r.arg[i] / 10;
            r.arg[i] = r.arg[i] % 10;
            i++;
        }
        r.len = (i >= 0) ? i + 1 : 1;
        return r;
    }
    friend BigInteger operator*(BigInteger w, int x)
    {
        BigInteger r;
        if(x == 0 || (w.len == 1 && w.arg[0] == 0)){
            return r;
        }
        for (int i = 0; i < w.len; i++){
            r.arg[i] += w.arg[i] * x;
            r.arg[i + 1] += r.arg[i] / 10;
            r.arg[i] = r.arg[i] % 10;
        }
        int i = r.arg[w.len] == 0 ? w.len-1 : w.len;
        while (r.arg[i] >= 10){
            r.arg[i + 1] = r.arg[i] / 10;
            r.arg[i] = r.arg[i] % 10;
            i++;
        }
        r.len = (i >= 0) ? i + 1 : 1;
        return r;
    }
    friend BigInteger operator*(BigInteger r, BigInteger w)
    {
        BigInteger v;
        if((r.len == 1 && r.arg[0] == 0)|| (w.len == 1 && w.arg[0] == 0)){
            return v;
        }
        for (int i = 0; i < r.len; i++){
            for (int k = 0; k < w.len; k++){
                v.arg[i + k] += w.arg[k] * r.arg[i];
                v.arg[i + k + 1] += v.arg[i + k] / 10;
                v.arg[i + k] = v.arg[i + k] % 10;
            }
        }
        int i = w.len + r.len - 1;
        i = v.arg[i] == 0 ? i-1 : i;
        while (v.arg[i] >= 10){
            v.arg[i + 1] = v.arg[i] / 10;
            v.arg[i] = v.arg[i] % 10;
            i++;
        }
        v.len = (i >= 0) ? i + 1 : 1;
        return v;
    }

    friend BigInteger operator/(BigInteger r, int w)
    {
        BigInteger  h, resl;
        if(w == 0) return h;
        for (int i = r.len - 1; i >= 0; i--){
            resl = 10 * resl;
            h = r.arg[i] + (10 * h);
            while (w <= h){
                resl = 1 + resl;
                h = h - w;
            }
        }
        return resl;
    }
    friend BigInteger operator/(BigInteger r, BigInteger w)
    {
        BigInteger h, resl;
        if(w.len == 1 && w.arg[0] == 0) return h;
        for (int i = r.len - 1; i >= 0; i--){
            resl = 10 * resl;
            h = r.arg[i] + (10 * h);
            while (w <= h){
                resl = 1 + resl;
                h = h - w;
            }
        }
        return resl;
    }

    friend BigInteger operator%(BigInteger r, BigInteger w)
    {
        BigInteger h;
        if(w.len == 1 && w.arg[0] == 0) return h;
        for (int i = r.len - 1; i >= 0; i--){
            h = r.arg[i] + (10 * h);
            while (w <= h){
                h = h - w;
            }
        }
        return h;
    }
    void sqrt()
    {
        BigInteger w, r;
        w.len = r.len = 0;
        int lens = len - 1;
        if(len == 1 && arg[0] == 1)
            return ;
        r.arg[r.len++] = arg[lens--];
        if (len % 2 == 0)
            r = arg[lens--] + 10 * r;
        while (lens >= -1){
            int i = 0;
            while ((i*(i + 20 * w)) <= r){
                i++;
            }
            i--;
            if (i == -1 || (r.len == 1 && r.arg[0] == 1))
                i = 0;
            r = r - (i*(i + 20 * w));
            w = i + 10 * w;
            if(lens >= 0){
                r = arg[lens--] + 10 * r;
                r = arg[lens--] + 10 * r;
            }
            else
                lens -= 2;
        }
        *this = w;
    }
};

带小数的大数模板：

struct BigDecimal{
    BigDecimal(int x){
        IntToBigDecimal(x);
    }
    BigDecimal(char *str = "0"){
        CharToBigDecimal(str);
    }
    int arg[1005];
    int len,point;//长度，小数位数
    void print()
    {
        for(int i = len-1; i >= 0; i--){
            cout<<arg[i];
            if(i == point && i)
                cout<<".";
        }
        cout<<endl;
    }
    void Clear()
    {
        int k = 0;
        while(point > 0 && arg[k] == 0)
            point--,k++;
        if(k == 0)
            return ;
        BigDecimal w;
        w.len = len - k;
        w.point = point;
        for(int i = 0; i < w.len; i++){
            w.arg[i] = arg[i+k];
        }
        *this = w;
    }
    void CharToBigDecimal(char *str)
    {
        int k = -1, flag = 0;
        point = 0;
        len = strlen(str);
        memset(arg, 0, sizeof(arg));
        while(++k < len){
            if(str[len-k-1] == '.'){
                point = k;
                flag = 1;
            }
            else{
                arg[k-flag] = str[len-k-1]-48;
            }
        }
        if(point != len-1)
            len = len - flag;
        while(len > point+1 && arg[len-1] == 0)
            len--;
        Clear();
    }
    void IntToBigDecimal(int x)
    {
        len = 0;
        point = 0;
        memset(arg, 0, sizeof(arg));
        do{
            arg[len++] = x % 10;
            x = x / 10;
        }while (x);
    }
    void Aligning(int cheap)
    {
        BigDecimal v;
        v.len = len - cheap;
        v.point = point - cheap;
        while(len--){
            v.arg[len-cheap] = arg[len];
        }
        *this = v;
    }
    friend bool operator<=(BigDecimal r, BigDecimal w)
    {
        if(r.len - r.point > w.len - w.point)
            return false;
        else if(r.len - r.point < w.len - w.point)
            return true;
        if(r.point < w.point){
            r.Aligning(r.point - w.point);
        }
        if(w.point > w.point){
            w.Aligning(w.point - r.point);
        }
        for(int i = r.len - 1; i >= 0; i--){
            if(r.arg[i] < w.arg[i]) return true;
            if(r.arg[i] > w.arg[i]) return false;
        }
        return true;
    }
    friend BigDecimal operator+(BigDecimal r, BigDecimal w)
    {
        if(r.point < w.point)
            swap(r, w);
        int cheap = r.point-w.point;
        int len = r.len > w.len+cheap ? r.len : w.len+cheap;
        for(int i = 0; i < len ; i++){
            if(i-cheap >= 0)
                r.arg[i] = r.arg[i] + w.arg[i-cheap];
            r.arg[i+1] += r.arg[i]/10;
            r.arg[i] = r.arg[i]%10;
        }
        while(r.arg[len] >= 10){
            r.arg[len+1] += r.arg[len]/10;
            r.arg[len] = r.arg[len]%10;
        }
        r.len = r.arg[len] == 0 ? len : len+1;
        r.Clear();
        return r;
    }
    friend BigDecimal operator+(int x, BigDecimal w){
        BigDecimal r(x);
        return r + w;
    }
    friend BigDecimal operator+(BigDecimal w, int x){
        BigDecimal r(x);
        return r + w;
    }
    friend BigDecimal operator-(BigDecimal r, BigDecimal w)
    {
        int cheap = r.point - w.point;
        if(cheap < 0){
            r.Aligning(cheap);
            cheap = 0;
        }
        for (int i = 0; i < r.len; i++){
            if (i - cheap >= 0 && r.arg[i] >= w.arg[i-cheap])
                r.arg[i] = r.arg[i] - w.arg[i-cheap];
            else if(i - cheap >= 0){
                r.arg[i] = r.arg[i] + 10;
                r.arg[i + 1] = r.arg[i + 1] - 1;
                r.arg[i] = r.arg[i] - w.arg[i-cheap];
            }
        }
        while (r.len - 1 > r.point && r.arg[r.len - 1] == 0)
            r.len--;
        r.Clear();
        return r;
    }
    friend BigDecimal operator-(BigDecimal w, int x){
        BigDecimal r(x);
        return r - w;
    }
    friend BigDecimal operator*(BigDecimal r, BigDecimal w)
    {
        BigDecimal v;
        if((r.len == 1 && r.arg[0] == 0)|| (w.len == 1 && w.arg[0] == 0)){
            return v;
        }
        v.point = r.point+w.point;
        for (int i = 0; i < r.len; i++){
            for (int k = 0; k < w.len; k++){
                v.arg[i + k] += w.arg[k] * r.arg[i];
                v.arg[i + k + 1] += v.arg[i + k] / 10;
                v.arg[i + k] = v.arg[i + k] % 10;
            }
        }
        int i = w.len + r.len - 1;
        i = v.arg[i] == 0 ? i-1 : i;
        while (v.arg[i] >= 10){
            v.arg[i + 1] = v.arg[i] / 10;
            v.arg[i] = v.arg[i] % 10;
            i++;
        }
        v.len = (i >= 0) ? i + 1 : 1;
        v.Clear();
        return v;
    }
    friend BigDecimal operator*(int x, BigDecimal w){
        BigDecimal r(x);
        return r * w;
    }
    friend BigDecimal operator*(BigDecimal w, int x){
        BigDecimal r(x);
        return r * w;
    }
    friend BigDecimal operator/(BigDecimal r, BigDecimal w)
    {
        BigDecimal h, resl;
        int len = r.point > w.point ? r.point : w.point;
        for(int i = 0; i < len; i++){
            r = r * 10;
        }
        r = r * 100000000;
        if(w.len == 1 && w.arg[0] == 0) return resl;
        for (int i = r.len - 1; i >= 0; i--){
            resl = 10 * resl;
            h = r.arg[i] + (10 * h);
            while (w <= h){
                resl = 1 + resl;
                h = h - w;
            }
        }
        resl.point = len + 8;
        resl.Clear();
        return resl;
    }
    friend BigDecimal operator/(BigDecimal w, int x){
        BigDecimal r(x);
        return r / w;
    }
    BigDecimal sqrt()
    {
        int cheap = point;
        while(point > 0){
            point -= 2;
        }
        if(point == -1){
            point = 0;
            *this = *this * 10;
        }
        *this = (*this) * 100000000;
        int lens = len - 1;
        if(len == 1 && arg[0] == 1)
            return *this;
        BigDecimal w, r;
        w.len = r.len = 0;
        r.arg[r.len++] = arg[lens--];
        if (len % 2 == 0)
            r = arg[lens--] + 10 * r;
        while (lens >= -1){
            int i = 0;
            while ((i*(i + 20 * w)) <= r){
                i++;
            }
            i--;
            if (i == -1 || (r.len == 1 && r.arg[0] == 1))
                i = 0;
            r = r - (i*(i + 20 * w));
            w = i + 10 * w;
            if(lens >= 0){
                r = arg[lens--] + 10 * r;
                r = arg[lens--] + 10 * r;
            }
            else
                lens -= 2;
        }
        w.point += (4 + (cheap +1 ) / 2);
        w.Clear();
        return w;
    }
};
achonor
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
大数取模&大数开平方
weixin_43946167的博客
03-10 1079
大数取模 蓝桥杯中经常会让运算结果对某一个很大的数取模作为最终结果。而往往运算结果本身就是一个十分巨大的数。这时不能把运算结果直接对这个很大的数取模。实际上运算结果在程序中是多次加法得到的，只需要在每次得到部分结果时就对其进行取模运算。再相加就得到最终结果。 例如： 27/7=3...6 (27=17+10) 17/7=2...3 10/7=1...3 可见，3=(2+1);6=(3+3) ...
大数的加减乘除开方
09-29
本来开发计算器,发现要用到大数运算，于是写了本代码。包括大数的加减乘除，开方，包括浮点，符合处理。纯C语言，在VS2010上测试OK，未知BUG若干。
大数模版
java开发指南博客 【转载】
08-24 151
#include &lt;iostream&gt; #include &lt;cstring&gt; using namespace std; #define DIGIT 4 //四位隔开,即万进制 #define DEPTH 10000 //万进制 #define MAX 100 typedef int bignum...
高精度模板(含大数开平方)
JayYe的专栏
09-25 2178
高精度模板(含大数开平方)
大数模板（加减乘除幂次开方）
TT4191105的博客
09-16 135
很好用的模板，但当时做题的时候从哪里找的不知道了，原作看到知会我一声我补上hhh 1 struct BigInteger 2 { 3 int len; 4 int arg[500]; 5 BigInteger(int x = 0) { 6 IntToBigInteger(x); 7 } 8...
大数运算（模板）
weixin_30544657的博客
06-06 107
转自六种实现了加减乘除和求余1、大数加法string add(string a,string b) { string c; int len1=a.length(); int len2=b.length(); int len=max(len1,len2); for(int i=len1;i<len;i++) ...
C++ 大数运算 加减乘除
03-16
通过编写大数类并实现加减乘除的方法，我们可以有效地处理大数运算。在实际项目中，也可以使用现有的库，如GMP（GNU Multiple Precision Arithmetic Library）或者Boost.Multiprecision库，它们提供了完善的接口和...
大数加减乘除c++类
11-18
这个题目涉及到了创建一个名为`BigInteger`的类来实现大数的加、减、乘、除运算以及比较操作。这里我们将详细解析这段代码中的各个部分。 首先，`BigInteger`类有两个私有成员变量：`vector<int> num`用于存储大数...
java 数组实现大数加减乘除运算
02-02
实际应用中，Java的`BigInteger`类提供了完整的功能，包括加减乘除和其他高级运算，而且性能经过优化，建议在处理大数运算时优先考虑使用。 总的来说，通过数组实现大数运算是一种基础的编程练习，它有助于深入理解...
两个大数的加减乘除
11-21
"两个大数的加减乘除" 大数运算是计算机科学中一个非常重要的领域，特别是在金融、科学计算和密码学等领域。今天，我们来讨论两个大数的加减乘除运算。 首先，让我们来讨论大数的概念。什么是大数？大数是指 those...
C++快速幂与大数取模算法示例
09-01
主要介绍了C++快速幂算法和大数取模算法的示例，对C++程序员来说有一定的帮助，有需要的朋友可以参考借鉴，下面来一起看看。
c++ 大数类 大数模板
weixin_30462049的博客
04-17 248
转自：http://blog.csdn.net/hackbuteer1/article/details/6595881 这个模板 用c++类写的, 有点晕(麻烦) 自己有添加了几个模板 快速幂取余模板 const int MAXN=10000; typedef long long ll; ll fun(ll n,ll x) { ll ans=1; ...
蓝桥杯PREV-34（数论+大数相乘大数开方模板）
RockyHOO1209的博客
12-21 399
思路：要推出一开始有多少枚硬币反面朝上，我们从最终全部正面朝上开始出发，对每个位置进行Q操作得出初态。然后现在来考虑，对于任意一枚正面朝上的硬币，经过奇数次的反转，肯定变为反面朝上。所以只要计算经过奇数次反转的硬币就可以得出答案了。接下来要做就是对于某一个位置的硬币(x,y)它的反转次数的奇偶如何确定呢。手动模拟可以得出结论：能影响到（x,y)反转的是（i,j)(i,j分别是x和y的约数）。组合起
java 大整数开方模板与常用方法
zyy.cpp 的博客
10-29 1018
BigInteger开方：public static BigInteger Sqrt(BigInteger xx) { BigDecimal x=new BigDecimal(xx); BigDecimal n1=BigDecimal.ONE; BigDecimal ans=BigDecimal.ZERO; while((n1.multiply(n1).subtract(x)).abs(
大数开方，大数相乘
huanhuanxiaoxiao的博客
02-03 1194
计算两个很大的数的开方后的乘积 #include #include using namespace std; //两个字符串相乘 string strMultiply(string str1 , string str2) { string strResult = ""; int len1 = str1.length(); int len2 = str2.lengt
【模板】多项式乘除取模，开方，求逆元，对数
继续学吧
12-03 647
证明什么的这个博主写的很详细了 这里只给出代码 多项式乘，除（取模），求逆元： 例题–luoguP4512 #include&amp;lt;iostream&amp;gt; #include&amp;lt;cstdio&amp;gt; #include&amp;lt;algorithm&amp;gt; #include&amp;lt;cstring&amp;gt; #include&amp;lt;cmath&amp;gt; #d
C++ 大数运算（加减乘除取模）
weixin_30918415的博客
08-31 896
加法：（字符串模拟小学加法） 1 string add(string s1, string s2) { 2 int len1 = s1.length(), len2 = s2.length(); 3 int maxlen = max(len1, len2) + 1; 4 string res(maxlen, '0'); 5 int ...
C++大数取模的一般方法
qq_62729874的博客
04-03 3890
一般来说，如果某一个数不太大，我们可以直接与另一个不太大的数直接取余求模。但有些数的长度可能会是百位甚至千位，这时候C++的 unsigned long long 也无法存下它们，我们就需要别的思路和方法来对它们取模。 假如有一个十进制数字串，比如3456，那么它可以拆分成(((3*10+4)*10+5)*10+6)，之后对每一步取余，假设跟5取余，则有：(3*10+4)%5==4, (4*10+5)%5==0, (0*10+6)%5==1。即3456对5取模值为1。那么当数字串更长时，同样可以用到这个
【多项式】多项式逆元/开方/取模/多点求值/插值/牛顿迭代/对数/exp/幂
03-19 2832
逆元已知多项式F(x)F(x)，求F(x)F(x)在保留前n项（当然n要是2的次幂）的情况下的逆元G(x)G(x)，也就是： F(x)G(x)≡1(modxn)F(x)G(x)\equiv 1 \pmod{x^n} 首先，如果n=1n=1，那么直接就是常数项的逆元，如果n&amp;amp;amp;amp;amp;amp;amp;gt;1n&amp;amp;amp;amp;amp;amp;amp;gt;1，那么怎么办？ 设：G′(x)G'(x)使得F(x)G′(x)≡1(modxn/2)
汇编实现 大数计算加减乘除
最新发布
06-08
以下是汇编实现大数计算加减乘除的基本思路： 1. 大数存储方式：使用数组存储，每个元素代表数值的一位，通常是按照十进制存储。 2. 大数加法：从低位到高位逐位相加，处理进位即可。 3. 大数减法：从低位到高位...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

achonor

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值