整数平方根的计算(一)

最新推荐文章于 2022-09-12 17:50:21 发布
最新推荐文章于 2022-09-12 17:50:21 发布
阅读量1w 收藏 3
点赞数
分类专栏： 算法 分数 大数运算 文章标签： float 算法 compiler div n2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liangbch/article/details/7263059
版权
算法 同时被 3 个专栏收录
27 篇文章 0 订阅
订阅专栏
大数运算
16 篇文章 1 订阅
订阅专栏
分数
1 篇文章 0 订阅
订阅专栏
 

     摘要：本文主要讨论使用求级数和的方法来计算小整数的平方根，在内存空间允许的情况下，本算法可将整数的平方根精确到任意精度。本算法具有逻辑简单，且无需使用大数库等优点。另外，本算法也相对高效，在当前主流的计算机上，计算整数的平方根到到10万位有效数字并输出到文件，大约需要5秒左右的时间。本文不但给出算法描述，也给出完整的C语言代码，其代码在VC和GCC下编译通过。

 

   为了描述其算法原理，请我们首先以二项式定理开始。二项式定理给出两个数之和的整数次幂诸如(x + y)n 展开为类似axbyc 项之和的恒等式，公式如下，

                                                                                                        (1)

其中   称为二项式系数，亦可记作  ,见文献[1]。特别的，当x=1，公式(1)可写成如下形式，

                           (2)

值得注意的是，不但a为正整数时，上述的公式成立，当为实数甚至复数时，上面公式亦同样成立，见文献[2]。当a=1/2，公式2 变为 

上面 (2K-3)!!和2k!!中的“!!”符号表示双阶乘，当n为奇数时，n!!=n ×(n-2)×(n-4)×* …1, 当n为偶数时，n!!=n×(n-2)×(n-4)× …2, 当n=0 或者-1时，n!!=1，见文献[3]。按照定义有 ，上面推导出来的公式可最终表示为：                                              (3)

其x的k次项的系数的递推公式为： ，

在文献[4] 给出如下公式，它实际上和(3)是一致的，不过(3)更简单些。

在文献[5] 和 文献[6]， 给出更多的这个级数的系数，他们是1, 1/2, -1/8, 1/16, -5/128, 7/256, -21/1024, 33/2048, -429/32768, 715/65536, -2431/262144, 4199/524288, -29393/4194304, 52003/8388608。

替换公式3中的“+x”为”-x”,可以发现，多项式中的所有系数都是负的，公式如下

                                                                                                     (4)

本文中的算法就是基于(4)，其主要方法如下

1. 找出x 的平方根的一个近似值 base，使得base稍大于x的平方根, base可表示为Q/P的形式。依下面的步骤，可推出N的平方根的一种表达式

 

                                                                                                        (5)

 例如：

  2. 若 ，对根式按照(4)展开，逐项求和，可得出一个稍小于1的数，然后乘以base，就得到最终的结果。

 

   下面分别介绍步骤1和步骤2的算法

   步骤1的目标是求出N的平方根的近似值的一个分数表示，记作Q/P，为了方便计算级数的和，Q2 不能大于计算机内置的整数类型，对于32位系统，要求Q2不能大于232-1。求1个浮点数的分数表示采用如下方法进行，逐步求精的迭代过程。

     1.1 在迭代之初，求出N的平方根为s，s用c数学库函数sqrt来计算，可精确到15-16位10进制数字，然后计算s的一个下界low和上界high。1.1到1.6的代码，请参照下文C代码中的函数findFraction。

     1.2 计算mid,取low和high的分母之和作为mid的分母，取low和high的分子之和作为mid的分子，容易证明，low<mid<high.

     1.3 比较mid的分子，若其平方超过内置整数的最大值，则转步骤1.5.

     1.4 比较s和mid的值，若mid>s, 用mid的值替换high原有的值，记作high←mid，否则low←mid

     1.5 转1.2，继续下一次迭代。

     1.6 base←high

   容易看出，步骤1.2到1.5是一个迭代的过程，整个过程类似2分查找。在整个迭代过程中，区间high-low越来越小，high也就越来越近似于N的平方根

   得到base=P/Q的值，利用(5)就可求出rem的值。

  

  2. 计算 的值，可使用公式(4)来求，rem具有这样的特点，分子很小而分母较大，容易知道，rem越小，级数收敛的就速度越快。在计算过程中使用递推法。用res表示级数的和，暂时不考虑其正负，用item表示级数第i项的值。重复如下步骤，直到item足够小,其和便达到指定精度。下面的代码中rem.d表示rem的分母，rem.n表示rem的分子.

    2.1 item←1/2

    2.2 item=item*rem, 即item *=rem.n, item/=rem.d

    2.3 res += item

    2.4 i←2

    2.5 item *= rem.n, item/=rem.d

    2.6 item *= (2i-3), item /= 2i;

    2.7 res+=item

    2.8 检查item的值，如果item足够小，转2.11

    2.9 i++

    2.10 转2.5，继续求下一项item和item的和res

    2.11 将res乘以-1，这里采用求补的方法，类似于对数表示法，将小数部分求补，整数部分减1，如-0.1235 的补数表示为-1+(1-0.1235)=（-1）+0.8765。

    2.12 到此为止，res等于级数中除了第一项以外各项的和，即 。

    2.13 res+=1, 其整数部分从-1变为0

    2.14 res*=base.

    至此，N的平方根就计算完毕。

 

     下面的内容叙述任意精度数的表示法和其四则运算

     本文中的C程序用动态数组表示一个任意精度的定点小数，采用1000000000进制，数组元素的类型为C语言的内置整数类型unsigned long，数组的每个元素表示9位10进制数。结构体LONG_FLOAT定义了任意精度数的表示，data指针表示数组的地址。任意精度数采用定点格式，整数部分用数组data的第一个元素data[0]表示，小数部分用数组的其它元素表示。这样的表示刚好满足需要，因为小整数的平方根的整数部分恰好可用1个元素来表示。结构体LONG_FLOAT的成员len表示数组的长度，成员first_idx表示数组中第一个非0元素的偏移地址。在计算过程中，item的值会越来越小，其数组前部会出现连续的0，为了减少计算量，仅从第一个非0元素算起。first_idx>=len-1视为任意精度数的值为0。为保证精度，在创建数组时，实际分配的数组的长度要比所需的精度多2个单元。任意精度数的存储顺序和显示的顺序一致。在计算乘法和加法时，采用从右至左的顺序计算，在计算除法时，采用从左至右的顺序计算。

     

 本文中所需的任意精度计算仅仅涉及以下几种种运算。

    1. 两个任意精度定点数相加，函数LF_Add实现了两个同样长度的任意精度定点数的加法运算。

    2.任意精度定点数乘以一个单精度整数，单精度整数的类型定义为unsigned long，函数LF_Mul用于计算任意精度定点数以一个单精度整数。

    3.任意精度定点数除以一个单精度整数，函数LF_Div用于实现这一功能。

    4.求补运算，即计算-1乘以任意精度定点数的积，结果采用补码表示，函数LF_NEG用于实现这一功能。

    5.任意精度定点数的创建和初始化，函数LF_Init用于创建动态数组，并对各个元素清0. 其他函数包括GCD32等，函数GCD32用于计算2个单精度整数的最大公约数。 

 

下面为完整的源代码。

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <math.h>
#define RADIX   1000000000 
#define LOG10_RAD	9	//log10(RADIX)
#define MAX_WORD 0xffff

#if _MSC_VER > 1000		//The compiler is VC
typedef unsigned __int64 UINT64;
#else					//The compiler is GCC
typedef unsigned long long  UINT64;
#endif 

typedef unsigned long UINT32;
typedef struct _frac
{
	UINT32 n;  //numerator
	UINT32 d;  //denominator
}FRAC;

/*定义一个定点小数类型，
  数的有效数字存储在数组data[]中，每个数组元素data[i]可表示9位10进制数字。
  数组的长度为len,故可表示len*9位10进制数字,其中data[0]表示整数部分，data[1]到data[len-1]表示小数部分
  数字的存储顺序和显示顺序相同，如data[0]=2,data[1]=222212345,data[2]=111198765,则表示2.222212345111198765
  数组的前几个存储单元可能为0，为了节省计算量，可从数组的第一个非0元素开始算起。第一个非0数组单元的顺序号用first_idx表示，如first_idx=3,则表示data[0],data[1],data[2]全部为0
*/
typedef struct _long_float
{
	UINT32 *data;
	int len;
	int first_idx;
}LONG_FLOAT;

// 功能: 求n1,n2的最大公约数
int GCD32(UINT32 n1, UINT32 n2) //Greatest Common Divisor
{
	UINT32 modNum;
	UINT32 bigNum=  (n1>n2)?n1:n2;
	UINT32 smallNum=(n1<n2)?n1:n2;
	if (smallNum==0)
		return bigNum;
	while (1)
	{
		modNum=bigNum % smallNum;
		if (modNum==0)
			break;
		bigNum=smallNum;
		smallNum=modNum;
	}
	return smallNum;
}

void FRAC_set(FRAC *frac,UINT32 n,UINT32 d)
{
	frac->n=n; frac->d=d;
}

void LF_Init(LONG_FLOAT *pNum,int len)
{
	pNum->data=(UINT32 *)malloc(len*sizeof(UINT32));
	memset(pNum->data,0,sizeof(UINT32)*len);
	pNum->first_idx=0;
	pNum->len=len;
}

void LF_Free(LONG_FLOAT *pNum)
{
	free(pNum->data);
	pNum->len=0;
}

void LF_Add(LONG_FLOAT *pTarget,const LONG_FLOAT *pSrc)
{
	int i;
	UINT32 t,c;
	for (c=0,i=pSrc->len-1;i>=pSrc->first_idx;i--)
	{
		t=pTarget->data[i] + pSrc->data[i] +c;
		c=0;
		if (t>=RADIX)
		{ t-=RADIX; c=1;}
		pTarget->data[i]=t;
	}
	
	while (c>0 && i>=0)
	{
		t=pTarget->data[i] + c;
		c=0;
		if (t>=RADIX)
		{ t-=RADIX; c=1;}
		pTarget->data[i--]=t;
	}
	
	pTarget->first_idx=i+1;
	if (i<0)
	{
		printf("Error in %d line\n",__LINE__);
		return ;
	}
}


void LF_Mul(LONG_FLOAT *pTarget,UINT32 k)
{
	int i;
	UINT64 t,c;
	for (c=0,i=pTarget->len-1;i>=pTarget->first_idx;i--)
	{
		t=(UINT64)(pTarget->data[i]) * (UINT64)k +c;
		pTarget->data[i]=(UINT32)(t % RADIX);
		c=(UINT32)(t / RADIX);
	}
	
	if (c>0)
	{
		if (i<0)
		{
			printf("Error in %d line\n",__LINE__);
			return;
		}
		pTarget->data[i]=(UINT32)c;
		pTarget->first_idx=i;
	}
}

//return remainder 
UINT32 LF_Div(LONG_FLOAT *pTarget,UINT32 k)
{
	int i;
	UINT64 t;
	UINT32 m=0;
	for (i=pTarget->first_idx;i<pTarget->len;i++)
	{
		t=(UINT64)m * (UINT64)RADIX + pTarget->data[i];
		pTarget->data[i]= (UINT32)(t / k);
		m=(UINT32)(t % k);
	}
	if (pTarget->data[pTarget->first_idx]==0)
		pTarget->first_idx++;
	return m;
}

void LF_NEG(LONG_FLOAT *pTarget)
{
	int i=pTarget->len-1;
	
	while (pTarget->data[i]==0)	i--;
	if (i>0)
	{
		pTarget->data[i]=RADIX-pTarget->data[i];
		i--;
		while (i>=1)
		{	pTarget->data[i]=(RADIX-1)-pTarget->data[i]; i--;}
	}
	pTarget->data[0]--;
	pTarget->first_idx=0;
}

/*
  Find a fraction x, such that x equal to f approximatively and x>f
*/
FRAC findFraction(double f)
{
	FRAC low,mid,high;
	UINT32 c,root_n;
	
	double f1=f- floor(f);
	root_n=(UINT32)(floor(f));
	if ( f1 <= 0.5)  
    {  
        c=(UINT32)(1.0/f1);  
		FRAC_set(&low, 1,c+1);
		FRAC_set(&high,1,c);
    }  
    else  
    {  
        c=(UINT32)(1.0/(1.0-f1));  
        FRAC_set(&low, c-1,c);
		FRAC_set(&high,c,c+1);
    }

	low.n  +=  root_n * low.d;
	high.n +=  root_n * high.d;
	
	if ( high.n> MAX_WORD)
	{
		FRAC_set(&low,  root_n,1);
		FRAC_set(&high, root_n+1,1);
	}

	while (1)
	{
		FRAC_set(&mid,low.n+high.n,low.d+high.d);
	    if ( mid.n  >= MAX_WORD)
			break;
		if ( (double)(mid.n)/(double)(mid.d) > f)
			high=mid;
		else
			low=mid;
	}
	return high;
}

void calc_sqrt(UINT32 N, LONG_FLOAT *pItem, LONG_FLOAT *pResult )
{
	int i;
	UINT32 max_UINT32,tGCD;
	FRAC base,rem;
	double f;

	f=sqrt((double)(N));
	/* 
	assume base approximatively equal to sqrt(N) and base>sqrt(N),
	      sqrt(N)
		    = base * sqrt(1- rem) 
            = base * sqrt(1-(N * base.d * base.d)/( base.n * base.n))
	*/
	base= findFraction(f);
	FRAC_set(&rem,(base.n * base.n)-N*base.d*base.d,base.n * base.n);
	tGCD=GCD32(rem.n,rem.d);
	if (tGCD>1) 
	{  rem.n /= tGCD;  rem.d /= tGCD; }
	
	printf("sqrt(%u)=(%u/%u)/sqrt(1-%u/%u)\n",N, base.n,base.d,rem.n,rem.d);

	// item[1] = rem * 1/2
	// item[i] = item[i-1] * rem * (2*i-1)/(2*i+1))	
	// result  = 1-sum(item[i]) where i=2 up to x and item[x]<10^-d)
	pItem->data[1]=RADIX/2;	// calculating item[1], now item=1/2
	LF_Mul(pItem,rem.n);	// item[1]= item[1] * rem, now the item=1/2*rem
	LF_Div(pItem,rem.d);	
	LF_Add(pResult,pItem);  //sum= sum + item[i]
	
	i=2;
	max_UINT32=~0;
	while (pItem->first_idx < pItem->len)
	{
		if (  rem.n * (2*i-3) < max_UINT32)
		{
			LF_Mul(pItem,rem.n*(2*i-3));	// item *= rem;
			LF_Div(pItem,rem.d);	// 
		}
		else
		{
			LF_Mul(pItem,rem.n);	// item *=rem
			LF_Div(pItem,rem.d);	// 
			LF_Mul(pItem,2*i-3);	// item *= (2i-3)/2i
		}
		LF_Div(pItem,2*i);		
		LF_Add(pResult,pItem);      //sum= sum + item[i]
		i++;
	}
	
	LF_NEG(pResult);		//pResult= - pResult;
	pResult->data[0] +=1;	//pResult=pResult+1;

	LF_Mul(pResult,base.n);		//result=result * base
	LF_Div(pResult,base.d);		
}

//calculating sqrt(n) to d decimal digtal and print the result
void calc_print(UINT32 n,int d)
{
	int i,buffLen;
	LONG_FLOAT item,result;
	UINT32 r;
		
	r=(UINT32)(sqrt(n));
	if (r * r ==n)
	{ 
		printf("sqrt(%u)=%u\n",n,r);
		return ; 
	}
	
	buffLen=(d+LOG10_RAD-1)/LOG10_RAD+3;
	LF_Init(&item,buffLen);
	LF_Init(&result,buffLen);
	
	calc_sqrt(n,&item,&result);

	printf("\t=%u.",result.data[0]);
	for (i=1;i<buffLen-2;i++)
		printf("%09u",result.data[i]);
	printf("\n");

	LF_Free(&item);
	LF_Free(&result);
	
}

int main(int argc, char* argv[])
{
	UINT32 i;
	UINT32 base;

	base=2;
	for (i=base;i<base+100;i++)
	{
		calc_print(i,100);
	}
	return 0;	
}


 


版权所有，转载请注明出处。

参考文献：

[1] “Binomial theorem” from Wikipedia,http://en.wikipedia.org/wiki/Binomial_theorem.

[2] “Binomial series” from Wikipedia,http://en.wikipedia.org/wiki/Binomial_series

[3] Weisstein, Eric W., "Double Factorial " from MathWorld,http://mathworld.wolfram.com/DoubleFactorial.html

[4] “Square root” From Wikipedia,http://en.wikipedia.org/wiki/Square_root

[5]  https://oeis.org/A002596 : Numerators in expansion of sqrt(1+x).

[6] https://oeis.org/A046161:  a(n) = denominator of binomial(2n,n)/4^n. 


liangbch
关注
专栏目录
整数开方算法
btchengzi0的专栏
03-27 6615
1 目的 本文阐述了常用的开方算法的原理，重点描述了整数开方算法的实现并给出实例源码，旨在提高不带FPU的处理器处理开发的效率。 2 常用的开方算法 2.1 逼近法 2.1.1 二分法逼近 选取一个平方值大于目标值a的值b，和一个小于目标值的值c，取中间值d=(b+c)/2的平方e与a比较，若偏大，设置b的新值为d，否则设置c的新值为d...
Python基于二分查找实现求整数平方根的方法
09-21
而当我们需要计算一个非负整数的平方根时，也可以利用二分查找的思想来实现。这种方法通常比直接使用内置的数学函数（如math.sqrt()）更快，尤其是在处理大数据量的情况下。 首先，理解二分查找的基本原理。二分...
求整数的平方根
qq_36226362的博客
11-02 1146
给定一个非负整数 x ，计算并返回 x 的平方根，即实现int sqrt(int x)函数。 正数的平方根有两个，只输出其中的正数平方根。 如果平方根不是整数，输出只保留整数的部分，小数部分将被舍去。 思路一：暴力破解 对于这个题，首先能想到的就是通过暴力解法来计算，对于所有i∈[1,x]来说，存在以下情况： x/i=i --> i就是x的平方根，直接返回i x/i>i --> i小于x的平方根，需要i++ x/i<i --> i大于x的平方根，后面就不需要遍..
整数平方根算法
红星科技的专栏
11-17 1171
这几天在作dsp程序的时候用到的，感觉还不错V_UINT32 VSqrt3( V_UINT32 x )  //牛顿法{ V_UINT32 x1; int s = 1, g0,g1; if (x  x1 = x - 1; if ( x1 > 65535 )  {  s += 8;  x1 >>= 16; } if ( x1 > 255 )  {  s += 4;  x1 >>= 8; } if
正确求平方根的整数部分方法
dongdipqaun7685的专栏
04-20 1638
k=sqrt(n)，由于其原型是double sqrt(double),他的返回值和参数都是double型，浮点数据只是对一定范围内的实数的一种近似表示，并不精确。 与我们要求得似是而非，存在错误。 通过数学方法，可以正确求出平方根或者其整数部分。 1=1*1； 1+3=2*2； 1+3+5=3*3； ~~~ 1+3+5+~+(2k-1)=k*k; odd=1,k=1...
69. x 的平方根给你一个非负整数 x ，计算并返回 x 的 算术平方根 由于返回类型是整数，结果只保留 整数部分
11-11
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
cpp代码-求一个正整数的平方根
07-14
这篇文档将详细介绍如何在C++中计算一个正整数的平方根，并以`main.cpp`和`README.txt`两个文件为例进行讲解。 首先，C++标准库提供了一个名为`std::sqrt`的函数，它位于`<cmath>`头文件中。这是最直接且简单的方法...
15条装配线上的整数平方根
04-01
标题中的“15条装配线上的整数平方根”指的是使用汇编语言编写的一个算法，该算法通过15条指令来实现对整数求平方根的功能。在计算机科学中，汇编语言是一种低级编程语言，它直接对应于机器语言，每一条指令通常对应...
整数平方根：整数开方及大整数开方解决方法
weixin_30709809的博客
11-03 916
求整数N的开方，精度在0.001 二分法 若N大于1,则从[1, N]开始，low = 1, high = N, mid = low + (high - low) >> 1开始进行数值逼近 若N小于1,则从[N, 1]开始，low = 0, high = N, mid = low + (high - low) >> 1开始进行数值逼近 ...
DS查找——折半查找求平方根
夜阑優琿
12-07 530
题目： 问题 D: DS查找——折半查找求平方根 时间限制: 1 Sec 内存限制: 128 MB 提交: 292 解决: 241 [提交][状态][讨论版] 题目描述 假定输入y是整数，我们用折半查找来找这个平方根。在从0到y之间必定有一个取值是y的平方根，如果我们查找的数x比y的平方根小，则x2<y，如果我们查找的数x比y的平方根大，则x2>y，我们可以据此缩小查找范围，当我们查找的数足够准确时（比如满足|x2-y|<0.00001），就可以认为找到了y的平方根。 温馨提示： 计
一种计算正整数平方根的方法
Daniel_Deng_Chengdu的博客
06-27 3284
观察十进制的情况数值(a)　位数(m)　正整数平方根(b)　正整数平方根位数(n)1            1                         1                199          2                         9                1100        3                        10        ...
求正整数的平方根，不使用算法库
qq469617582的博客
07-04 852
输入一个正整数，输出其平方根，不可用使用数学类算法库 输入数据的平方根，只取整数部分 #include <iostream> #include<cstdio> using namespace std; int main() { cout<<"请输入一个正整数："<<endl; double x; cin>>x; i...
计算正整数平方根的整数部分(J2ME)
网络猎狐犬
01-04 2103
MIDP1.0不能使用浮点数,因此这个算法只能计算正整数开方的整数部分,且算法中没有任何乘法和除法运算,只有加减运算.算法原理:1+3+5+...+(2n-1) = n^2根据公式我们要求X的开方,只需让X-1,X-3,X-5....直到X为负数,这时所有成功的次数就是平方根的整数部分./**  * @todo 计算正整数平方根的整数部分  * @param x 要求平方根的正整数  * @ret
算术平方根的整数部分（简单）*求平方根的三种方法**整数与小数取绝对值*
weixin_44339614的博客
11-11 5338
69. Sqrt(x) - 力扣（LeetCode） (leetcode-cn.com)https://leetcode-cn.com/problems/sqrtx/ 目录 方法一：牛顿迭代法 PS：求取绝对值 方法二：通过其它的数学函数代替平方根函数得到精确结果，取整数部分作为答案； 方法三：二分法查找 方法一：牛顿迭代法 class Solution { public: int mySqrt(int x) { double result=(double)x;.
如何计算整数平方根
fanzitao的专栏
08-22 2629
算法1.猜试法 利用等差级数公式:                            这样的话, 从1开始一直算到数列的前项和第一次大于x的时候,即是所求。 unsigned linear_search(unsigned long x) { unsigned long sum_n = 1; unsigned n = 1; if(x <= 1)
整数开方 sqrt
pymqq的专栏
02-26 531
#include using namespace std; int sqrt(int x) {     inttest, step;     if(x          return-1;     if(x == 0)         return0;     step= 1     test= 0;     while(step != 0)     {         registerint h
C语言--用二分法快速计算指定整数的整数平方根
快乐天堂
09-12 1316
用二分法快速计算指定整数的平方根
sqrt函数的实现
weixin_33862188的博客
03-15 157
原文：http://blog.csdn.net/legend050709/article/details/39394381 sqrt算法实现： （一）int sqrt1(int n);求取整数x的平方根，向下取整； （0）步骤： 1.先求出范围；然后排序2.然后二分查找； （1）方法一:O(n) for(int i=0;i*i<n;i++);i=i-1; （2）方法二:二分查找...
python整数计算平方根
最新发布
05-20
你可以使用 math 模块中的 sqrt() 方法来计算整数的平方根。以下是一个示例代码： ```python import math num = 16 sqrt_num = math.sqrt(num) print("The square root of", num, "is", sqrt_num) ``` 输出： ``` The square root of 16 is 4.0 ``` 注意：如果要计算非整数的平方根，则需要使用浮点数。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值