二元多项式（简单链表操作，注释很好理解）

最新推荐文章于 2023-06-13 15:32:17 发布
最新推荐文章于 2023-06-13 15:32:17 发布
阅读量3.3k 收藏 24
点赞数 5
分类专栏： ACM训练+实训+大学编程练习 文章标签： 单链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FEATHER2016/article/details/76735803
版权

二元多项式

Time Limit: 1000MS Memory Limit: 65536KB
Submit Statistic Discuss
Problem Description

给你多个二元多项式和一个操作符，让你输出操作符操作这些二元多项式之后的结果。
Input

首先输入二元多项式的个数n和操作符号（‘+’，‘*’）；
后面n行输入每一个多项式。
多组输入，当n=0的时候结束输入。
（n<5,二元多项式的长度小于1000，二元多项式都是由x，y，^,数字，’+’组成的）
Output

输出操作之后的结果。
（输出的顺序按照：x^2>x>xy^2>xy>y^2>y>常数）
Example Input

2 +
3x+4y^2+3xy+6x^10y^2+1
2x+6y
0
Example Output

6x^10y^2+5x+3xy+4y^2+6y+1
Hint

Author

zp

时间过得真的是很快，转眼之间，暑假集训就已经两个周了，每天都是忙忙碌碌的，但是，心里是很开心的。
有一种题目，在你的心里，是一直都有印象的，我会觉得，我能记它一辈子，dqds曾经告诉我，你绝对记不住，以后你还会遇见更多的题目，真的记不住的~
其实，我很想说，我会记住的，可能就只记得他是一个什么类型的题目，也可能连类型都忘记了，但是，我就是知道~因为，我记住的或许不是题目本身，而是做这道题目的时候的心情，做题时的热情，很难想像，我以后会干什么，但是，这种青春时候的心情，真的是一辈子都不会忘记的！（我记得我说过，那一道题目，我会记一辈子，记得吗？！余弦，我记得）
我想说，这道题目，我也会记一辈子的，二元多项式~~~

AC代码：
有注释，一步步很好理解~

如果觉得烦琐，后面有没有注释的代码~

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
#define MAXN 12
struct node
{
    int x;//存储x的指数
    int y;//存储y的指数
    int num;//存储系数
    struct node *next;//指针域，指向下一个
}t[MAXN];//链表头结点
char str[12121];//输入的表达式
struct node * Creat()//初始化函数
{
    //定义一个链表的节点，初始化，并返回
    struct node * p;
    p = new struct node;
    p->next = NULL;
    p->x = 0;
    p->y = 0;
    p->num = 0;
    return p;
};
void Build(struct node * root)//建立链表
{
    struct node * p;//链表节点
    int len , data, ans;
    p = Creat();//初始化
    len = strlen(str);//表达式的长度
    data = 0;
    ans = 1;
    for(int i=len-1;i>=0;i--)//从后向前遍历表达式
    {
        if(str[i]>='0'&&str[i]<='9')//如果是数字的话，记录下来
        {
            data = (str[i]-'0')*ans+data;//data是十进制的数（不是字符）
            ans *= 10;//表示现在是在哪位（个，十，百）
        }
        else if(str[i]=='x')
        {
            if(data)//如果data存在，也就是现在x是多少次方
                p->x = data;//p->x存的是x的指数
            else
                p->x = 1;//否则，后面没有数字（从后向前遍历），则，指数为1
            data = 0;//清空data
            ans = 1;//指向各位
        }
        else if(str[i]=='y')
        {
            if(data)//如果data存在，也就是现在y是多少次方
                p->y = data;//p->y存的是y的指数
            else
                p->y = 1;//否则，后面（从后向前遍历）没有数字，则，指数为1
            data = 0;//清空data
            ans = 1;//指向各位
        }
        else if(str[i]=='+')//出现加号的时候
        {
            if(data)//如果后面（从后向前遍历）有数字，则为这个小的多项式系数
            {
                p->num = data;//p->num存系数
            }
            else if(p->x||p->y)//如果没有系数，并且，有x或y存在的话
            {
                p->num = 1;//系数更新为1
            }
            //逆序建立链表
            p->next = root->next;
            root->next = p;
            //清空data，ans指向各位
            data = 0;
            ans = 1;
            p = Creat();//定义并初始化p;
        }
    }
    //出循环之后，字符串的最前面，没有'+'，所以要再次建立
    if(data)//如果data存在
    {
        p->num = data;//就是多项式的系数
    }
    else if(p->x||p->y)//如果x或者y存在
    {
        p->num = 1;//系数为1
    }
    //逆序建立链表
    p->next = root->next;
    root->next = p;
}
void Link(struct node *Root, struct node * root)//两个链表相乘为一个链表
{
    struct node *p, *q, *temp, *t;
    temp = Creat();//定义并初始化一个新链表的头节点
    p = Root->next;//p指针指向其中一个（下面说第一个）链表的起始点
    while(p)//当第一个链表指针没有指向空时
    {
        q=root->next;//q指向第二个链表的起始点
        while(q)//当第二个链表指针没有指向空时
        {
            t = Creat();//定义并初始化t
            t->num = p->num*q->num;//将两个多项式的系数相乘
            //同底数幂相乘，底数不变，指数相加
            t->x = p->x+q->x;//t->x表示x的指数
            t->y = p->y+q->y;//t->y表示y的指数
            //将此节点，给了新链表，逆序建立新链表
            t->next=temp->next;  
            temp->next = t;
            //循环继续
            q = q->next;
        }
        p = p->next;
    }
    Root->next = temp->next;//将新链表给了旧链表的头结点
    free(temp);//释放空间，将暂时存储新链表的空间释放
}
void Sort(struct node * root)//合并多项式中重复的节点
{
    struct node *p, *q, *temp;
    p = root->next;//q指向链表的开始
    while(p)//当p不为空时
    {
        temp = p;//temp指向p
        q = p->next;//q指向p的下一个节点
        while(q)//当q不为空时
        {
            //如果x的指数，y的指数相等，并且，p的系数存在的话（排除空的情况）
            if(p->x==q->x&&p->y==q->y&&p->num)
            {
                p->num += q->num;//系数相加
                temp->next = q->next;//将q节点删除
                free(q);//释放空间
                q = temp->next;//q指向下一个节点
            }
            else if(p->num==0&&q->num==0)//否则，如果两个节点的系数全部为0
            {
                p->x = 0;//清空节点
                p->y = 0;
                temp->next = q->next;
                free(q);//释放q空间
                q = temp->next;
            }
            else//否则的话，不能合并，指向移动
            {
                temp = temp->next;
                q = q->next;
            }
        }
        p = p->next;
    }
    //***********接下来就是按照指数多少排序***********//
    p=root->next;//p指向链表的开始
    while(p)//当p不等于空的时候
    {
        q = p->next;//q指向p的下一个
        while(q)//当q不为空的时候
        {
            if(p->x<q->x)//如果p中x的指数小
            {
                //将p, q交换（交换节点内的元素，不变动链表位置）
                swap(p->x, q->x);
                swap(p->num, q->num);
                swap(p->y, q->y);
            }
            else if(p->x==q->x&&p->x)//如果p中x的指数和q中y的指数相等，并且不为0
            {
                //接下来比较y的指数大小（此种情况下，可能会没有y）
                if(q->y==0&&p->y!=0)//如果q中y的指数等于0并且p的指数不等于0
                {
                    //交换
                    swap(p->x, q->x);
                    swap(p->num, q->num);
                    swap(p->y, q->y);
                }
                else if(p->y<q->y&&p->y!=0)//否则，如果p中y的指数小于q中y的指数，并且p中y的指数不为0
                {
                    //交换
                    swap(p->x, q->x);
                    swap(p->num, q->num);
                    swap(p->y, q->y);
                }
                //当然，其他情况也有，但是不用交换，就忽略
            }
            else if(p->x==q->x&&p->x==0)//如果p中x的指数和q中y的指数相等，并且为0
            {
                //此时，y有指数，也可能为0
                if(p->y<q->y)
                {
                    //如果p中y的指数小，交换
                    swap(p->x, q->x);
                    swap(p->num, q->num);
                    swap(p->y, q->y);
                }
            }
            q = q->next;
        }
        p = p->next;
    }
}
void Output(struct node * root)//输出
{
    struct node * p;
    p = root->next;//链表的起始点
    while(p)
    {
        if(p!=root->next)//在每一项，除了最后一项的后面输出‘+’
        {
            printf("+");
        }
        if(p->num)//如果有系数存在
        {
            //若系数为1，并且没有x或者y的存在，不输出
            if(p->num!=1||(p->x==0&&p->y==0))
                printf("%d", p->num);
        }
        else//否则，输出0（没有系数，考虑0的情况）
        {
            printf("0");
            p = p->next;
            continue;//继续
        }
        if(p->x)//如果x指数存在
        {
            printf("x");//输出x
            if(p->x!=1)//如果指数不是1
                printf("^%d", p->x);//输出指数（否则，不用输出指数）
        }
        if(p->y)//如果y指数存在
        {
            printf("y");//输出y
            if(p->y!=1)//如果指数不是1
            {
                printf("^%d", p->y);//输出指数（否则，不用输出）
            }
        }
            p = p->next;
        }
        printf("\n");
}
int main()
{
    int n;
    char c[2];
    while(~scanf("%d",&n)&&n)//0的时候结束
    {
        scanf("%s",c);
        for(int i=0; i<=n; i++)//初始化，清空
        {
            t[i].next=NULL;
        }
        for(int i=1; i<=n; i++)
        {
            scanf("%s",str);//输入多项式
            Build(&t[i]);//建立链表
        }
        if(c[0]=='+')//判断执行的是加法操作
        {
            struct node *p;
            p=&t[0];
            for(int i=1; i<=n; i++)//合并链表
            {
                p->next=t[i].next;//每一个链表的头结点t[i]
                while(p->next)
                {
                    p=p->next;
                }
            }
        }
        else if(c[0]=='*')//判断执行的是乘法操作
        {
            t[0].next=t[1].next;
            for(int i=2; i<=n; i++)
            {
                Link(&t[0],&t[i]);//链表相乘
            }
        }
        Sort(&t[0]);//合并链表
        Output(&t[0]);//输出
    }
    return 0;
}
/************************************************
题目：二元多项式
难度：开始觉得很难，理解之后，觉得还行
目标：记住（一辈子）心情
备注：解释是用自己觉得好理解的语言，可能不规范
*************************************************/

无注释：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <algorithm>
using namespace std;
#define MAXN 12
struct node
{
    int x;
    int y;
    int num;
    struct node *next;
}t[MAXN];
char str[12121];
struct node * Creat()
{
    struct node * p;
    p = new struct node;
    p->next = NULL;
    p->x = 0;
    p->y = 0;
    p->num = 0;
    return p;
};
void Build(struct node * root)
{
    struct node * p;
    int len , data, ans;
    p = Creat();
    len = strlen(str);
    data = 0;
    ans = 1;
    for(int i=len-1;i>=0;i--)
    {
        if(str[i]>='0'&&str[i]<='9')
        {
            data = (str[i]-'0')*ans+data;
            ans *= 10;
        }
        else if(str[i]=='x')
        {
            if(data)
                p->x = data;
            else
                p->x = 1;
            data = 0;
            ans = 1;
        }
        else if(str[i]=='y')
        {
            if(data)
                p->y = data;
            else
                p->y = 1;
            data = 0;
            ans = 1;
        }
        else if(str[i]=='+')
        {
            if(data)
            {
                p->num = data;
            }
            else if(p->x||p->y)
            {
                p->num = 1;
            }
            p->next = root->next;
            root->next = p;
            data = 0;
            ans = 1;
            p = Creat();
        }
    }
    if(data)
    {
        p->num = data;
    }
    else if(p->x||p->y)
    {
        p->num = 1;
    }
    p->next = root->next;
    root->next = p;
}
void Link(struct node *Root, struct node * root)
{
    struct node *p, *q, *temp, *t;
    temp = Creat();
    p = Root->next;
    while(p)
    {
        q=root->next;
        while(q)
        {
            t = Creat();
            t->num = p->num*q->num;
            t->x = p->x+q->x;
            t->y = p->y+q->y;
            t->next=temp->next;  
            temp->next = t;
            q = q->next;
        }
        p = p->next;
    }
    Root->next = temp->next;
    free(temp);
}
void Sort(struct node * root)
{
    struct node *p, *q, *temp;
    p = root->next;
    while(p)
    {
        temp = p;
        q = p->next;
        while(q)
        {
            if(p->x==q->x&&p->y==q->y&&p->num)
            {
                p->num += q->num;
                temp->next = q->next;
                free(q);
                q = temp->next;
            }
            else if(p->num==0&&q->num==0)
            {
                p->x = 0;
                p->y = 0;
                temp->next = q->next;
                free(q);
                q = temp->next;
            }
            else
            {
                temp = temp->next;
                q = q->next;
            }
        }
        p = p->next;
    }
    p=root->next;
    while(p)
    {
        q = p->next;
        while(q)
        {
            if(p->x<q->x)
            {
                swap(p->x, q->x);
                swap(p->num, q->num);
                swap(p->y, q->y);
            }
            else if(p->x==q->x&&p->x)
            {
                if(q->y==0&&p->y!=0)
                {
                    swap(p->x, q->x);
                    swap(p->num, q->num);
                    swap(p->y, q->y);
                }
                else if(p->y<q->y&&p->y!=0)
                {
                    swap(p->x, q->x);
                    swap(p->num, q->num);
                    swap(p->y, q->y);
                }
            }
            else if(p->x==q->x&&p->x==0)
            {
                if(p->y<q->y)
                {
                    swap(p->x, q->x);
                    swap(p->num, q->num);
                    swap(p->y, q->y);
                }
            }
            q = q->next;
        }
        p = p->next;
    }
}
void Output(struct node * root)
{
    struct node * p;
    p = root->next;
    while(p)
    {
        if(p!=root->next)
        {
            printf("+");
        }
        if(p->num)
        {
            if(p->num!=1||(p->x==0&&p->y==0))
                printf("%d", p->num);
        }
        else
        {
            printf("0");
            p = p->next;
            continue;
        }
        if(p->x)
        {
            printf("x");
            if(p->x!=1)
                printf("^%d", p->x);
        }
            if(p->y)
            {
                printf("y");
                if(p->y!=1)
                {
                    printf("^%d", p->y);
                }
            }
            p = p->next;
        }
        printf("\n");
}
int main()
{
    int n;
    char c[2];
    while(~scanf("%d",&n)&&n)
    {
        scanf("%s",c);
        for(int i=0; i<=n; i++)
        {
            t[i].next=NULL;
        }
        for(int i=1; i<=n; i++)
        {
            scanf("%s",str);
            Build(&t[i]);
        }
        if(c[0]=='+')
        {
            struct node *p;
            p=&t[0];
            for(int i=1; i<=n; i++)
            {
                p->next=t[i].next;
                while(p->next)
                {
                    p=p->next;
                }
            }
        }
        else if(c[0]=='*')
        {
            t[0].next=t[1].next;
            for(int i=2; i<=n; i++)
            {
                Link(&t[0],&t[i]);
            }
        }
        Sort(&t[0]);
        Output(&t[0]);
    }
    return 0;
}
mrxs
关注
  • 5
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表应用------一元多项式
weixin_44034024的博客
03-04 1266
【问题描述】编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始是升序的，A与B之和按降序排列。例如： 多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5 多项式B: -1.2X^0 2.5X^1 3.2X^3 2.5X^5 5.4X^10 多项式A与B之和：5.4X^10 6.4X^3 5X^1 【输入形式】任意两个多项式...
链表实现多项式的加法(C语言)
最新发布
qq_67574411的博客
08-02 1561
用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。
多项式相加求和（C语言链表版）
qq_63438062的博客
04-14 1万+
多项式相加求和（C语言链表）
两个多项式相加的程序（链表）
leafdown_的博客
10-22 6375
思路： 1、定义结构体struct，包含元素coef,exp 2、创建链表输入函数 polypointer createLink(int n); 3、创建两个多项式相加的函数 polypointer PolyAdd(polypointer a,polypointer b); 其中，PolyAdd函数调用函数 polypointer Attach(int e,int c,polypoin
两个链表相加
私房菜
06-13 1298
例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。数据范围：0≤n,m≤1000000，链表任意值 0≤val≤9。给定两个这种链表，请生成代表两个整数相加值的结果链表。要求：空间复杂度 O(n)，时间复杂度 O(n)
链表（篇5）用链表实现多项式相加
有图有真相
03-18 5753
使用链接实现两个多项式相加例：输入： 第一数目= 5x ^ 2 + 4x ^ 1 + 2x ^ 0 第二数= 5x ^ 1 + 5x ^ 0 输出： 5x ^ 2 + 9x ^ 1 + 7x ^ 0 输入： 第一数量= 5x ^ 3 + 4x ^ 2 + 2x ^ 0 第二数= 5x ^ 1 + 5x ^ 0 输出： 5x ^
多项式相加链表实现.docx
04-21
该方法可以正确地处理多项式的相加操作，并且可以很好地处理大规模的多项式。 结论 本文中，我们使用链表来实现多项式的相加操作，并且分析了该算法的时间复杂度。实验结果表明，该方法是非常有效的，可以正确地...
saa.zip_多项式 加减_多项式 链表
09-19
首先，我们需要理解链表的基本概念以及如何构建表示多项式的链表结构。 链表是一种线性数据结构，与数组不同，它的元素不存储在连续的内存位置。每个元素称为一个节点，包含数据以及指向下一个节点的指针。在多项式...
数据结构实验 一元多项式运算 链表应用
07-18
在这个“数据结构实验：一元多项式运算 链表应用”中，我们将深入探讨如何使用C/C++语言来实现一元多项式的数学运算，并将这些运算与链表数据结构相结合。 一元多项式可以表示为一个形式如`a_nx^n + a_{n-1}x^{n-1}...
BiRoots:二元多项式系统的根工具箱-matlab开发
06-01
在这个工具箱中，这种方法被推广到二元多项式系统，并且根被计算为适当的双参数特征值问题的特征值。 如果 det(A+x*B+y*C) = p(x,y)，方阵 A,B,C 形成双变量多项式 p(x,y) 的行列式表示（或线性化）。 为了找到系统...
链表操作及多项式
01-04
通过实际编程，学生可以更好地理解链表的运作方式以及如何有效地处理多项式计算。 在C语言中实现链表，需要注意内存管理。由于C语言不提供自动垃圾回收，程序员必须手动分配和释放内存。使用malloc()函数分配节点，...
多项式加法运算（链表实现）
热门推荐
2021dragon的博客
04-24 1万+
文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数类型 typedef struct SListNode { SLTDataType coef;//系数 SLTDataType expon;//指数 struct SListNode* ne
浙江大学 PTA 程序 第三部分 统计字符 统计学生平均成绩与及格人 输出闰年 成绩转换 查询水果价格 比较大小 高速公路超速处罚 出租车计价 统计学生成绩 三角形判断
songbai220
07-11 1576
练习3-2计算符号函数的值(10分) 对于任一整数n，符号函数sign(n)的定义如下： 请编写程序计算该函数对任一输入整数的值。 输入格式: 输入在一行中给出整数n。 输出格式: 在一行中按照格式“sign(n) = 函数值”输出该整数n对应的函数值。 输入样例1: 10 输出样例1: sign(10) = 1 输入样例2: 0 输出样例2:...
用单链表实现两个多项式的相加运算，要求对于两个给定的有序多项式（按指数升序排列），能够正确得出它们相加的结果，编写程序实现之。
gjrsxmkc88的博客
11-28 967
用单链表实现两个多项式的相加运算，要求对于两个给定的有序多项式（按指数升序排列），能够正确得出它们相加的结果，编写程序实现之。 …表示不知道怎么写，希望各位大佬帮帮完成，在这里感谢。 #include<malloc.h> #include<conio.h> typedef struct { int coef; int expn; } ElemType; typedef struct LNode { ElemType data; struct LN
单链表实现多项式相加
qq_44886213的博客
04-30 3611
一、题目 依次输入两个多项式的项数，然后输入每一项的系数和指数，用空格隔开。 结果给出两个多项式相加的系数和指数。 二、解析 思路： （1）结构体包括三部分，系数、指数和next指针 （2）写一个创建单链表的函数，先询问用户多项式的项数，然后从首元结点开始依次存储每一项的系数和指数 （3）我用链表a去存储结果。两链表a,b比较时，需要三个指针。anow指向链表a当前需要比较的结点，bnow指向链表b当前需要比较的结点，因为后面的分析中需要用到前插法将结点插入a中，所以还需要anow的前驱结点apre。 （4
双向循环链表的实现与基本运算
big_C的博客
07-31 675
目录双向循环链表引入双向链表结点的描述双向循环链表的基本运算 双向循环链表引入 在单链表L中，查找ai的后继next（L，ai），耗时仅为o(1)，因为取ai之后的后继指针即可。但查找ai的直接前驱prior（L，ai），则需要从链表的头指针开始，找到结点ai前一节点即是。故运算prior（L，ai），依赖表长n,耗时为o(n)。另外，若链表中有一指针值被破坏，则整个链表就会脱节。这是单链表的不足，为此引入双链表。如下图： 双向链表结点的描述 即双链表的结点包含三个部分，两个指针域，一个数据域。
c语言——链表——多项式相加
qq_62136607的博客
01-18 3742
例题详解： 一个多项式可以表示为二元组序列{(a1,e1), (a2,e2), … (an,en)}, 其中ai表示第i项的系数（非零值）， ei表示第i项的指数。 编写函数建立多项式链表实现一个多项式的输入，按指数从高到低有序，返回链表的头指针。 3) 编写函数实现两个多项式相加，返回结果多项式链表的头指针。 4) 编写函数输出一个多项式的二元组序列。 5) 在main函数中分别调用上述函数，实现输入两个多项式，求出它们的和并输出结果。 6)...
数据结构：用链表表示多项式，并实现多项式的加法运算（C语言）
m0_51617352的博客
11-05 8638
输入格式: 输入在第一行给出第一个多项式POLYA的系数和指数，并以0,0 结束第一个多项式的输入； 在第二行出第一个多项式POLYB的系数和指数，并以0,0 结束第一个多项式的输入。 输出格式: 对每一组输入，在一行中输出POLYA+POLYB和多项式的系数和指数。 输入样例: 5,0 2,1 1,6 8,15 0,0 -2,1 3,6 4,8 0,0 输出样例: 5,0 4,6 4,8 8,15 分析 首先要进行头文件的说明和结构体的定义 #include<stdi.
用两个链表实现两个多项式相加
weixin_46458146的博客
04-02 1511
创建三个链表La,Lb,Lc，把La，Lb按照x的指数从小到大的连接在Lc上 输出：La,Lb,Lc,再销毁La，Lb； 代码如下： #include <stdio.h> #include <stdlib.h>//malloc需要 typedef struct PLnode{ float xishu;//系数 int zhishu;//指数 ...
数据结构学习：多项式导数与链表操作
"该文档包含了数据结构学习过程...这些都是链表数据结构的基础，对于理解和操作链表非常重要。 这份文档提供了数据结构学习者所需要的一些基础和进阶算法实现，可以帮助他们更好地理解这些概念，并应用于实际编程中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值