快速矩阵乘法 strassen算法、coppersmith-winograd算法

最新推荐文章于 2022-10-13 15:00:16 发布
最新推荐文章于 2022-10-13 15:00:16 发布
阅读量3.6k 收藏 12
点赞数 2
原文链接：http://hongbomin.com/2016/07/19/fast-matrix-multiplication/
版权

竹杖芒鞋轻胜马，一蓑烟雨任平生
首页

标签

分类

归档

关于
快速矩阵乘法
发表于 2016-07-19 | 分类于 算法 ， 性能优化 | 0 | 阅读次数: 5055
矩阵乘法
矩阵乘法是高性能计算以及深度学习的基石之一，矩阵乘法的优化一直是相关业界的关注重点。
矩阵乘法的定义非常简单，定义见：wiki。

最简单的矩阵乘法实现
最简单的矩阵乘法实现，时间复杂度为O^3。

static void mm_generate(float* matA,float* matB,float* matC,const int M,const int N,const int K,const int strideA,const int strideB,const int strideC)
{
for (int i = 0; i < M;i++)
{
for (int j = 0; j < N;j++)
{
float sum = 0.0f;
for (int k = 0; k < K;k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[i*strideC + j] = sum;
}
}
}
转化为分块计算
矩阵转换为分块实现，时间复杂度仍然是O^3。

static void mm_split(float* matA, float* matB, float* matC, const int M, const int N, const int K, const int strideA, const int strideB, const int strideC)
{
memset(matC, 0, MstrideCsizeof(float));
//C11 = A11xB11 + A12XB21
for (int i = 0; i < M/2; i++)
{
for (int j = 0; j < N/2; j++)
{
float sum;
//A11XB11
sum = 0.0f;
for (int k = 0; k < K/2; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
//A12XB21
sum = 0.0f;
for (int k = K / 2; k < K; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
}
}
//C12 = A11XB12 + A12XB22
for (int i = 0; i < M / 2; i++)
{
for (int j = N/2; j < N; j++)
{
float sum;
//A11XB11
sum = 0.0f;
for (int k = 0; k < K / 2; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
//A12XB21
sum = 0.0f;
for (int k = K / 2; k < K; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
}
}
//C21 = A21XB11 + A22XB21
for (int i = M/2; i < M; i++)
{
for (int j = 0; j < N / 2; j++)
{
float sum;
//A11XB11
sum = 0.0f;
for (int k = 0; k < K / 2; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
//A12XB21
sum = 0.0f;
for (int k = K / 2; k < K; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
}
}
//C22 = A21XB12 + A22XB22
for (int i = M/2; i < M; i++)
{
for (int j = N/2; j < N; j++)
{
float sum;
//A11XB11
sum = 0.0f;
for (int k = 0; k < K / 2; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
//A12XB21
sum = 0.0f;
for (int k = K / 2; k < K; k++)
{
sum += matA[istrideA + k] * matB[kstrideB + j];
}
matC[istrideC + j] += sum;
}
}
}
Strassen算法
Strassen算法，时间复杂度是O^2.81。定义见：wiki
c++实现：

static void mm_strassen(float* matA, float* matB, float* matC, const int M, const int N, const int K, const int strideA, const int strideB, const int strideC)
{
if ((M <= 64) || (M%2 != 0 ||N%2 != 0 ||K%2!=0))
{
return mm_generate(matA, matB, matC, M, N, K, strideA, strideB, strideC);
}
memset(matC, 0, MstrideCsizeof(float));
int offset = 0;

//M1 = (A11+A22)*(B11+B22)
std::vector<float> M1((M / 2) * (N / 2));
{
	memset(&M1[0], 0, M1.size()*sizeof(float));
	//M1_0 = (A11+A22)
	std::vector<float> M1_0((M / 2) * (K / 2));
	offset = M*strideA / 2 + K / 2;
	for (int i = 0; i < M / 2; i++)
	{
		for (int j = 0; j < K/2; j++)
		{
			const int baseIdx = i*strideA + j;
			M1_0[i*K/2+j] = matA[baseIdx] + matA[baseIdx + offset];
		}
	}
	//M1_1 = (B11+B22)
	std::vector<float> M1_1((K / 2) * (N / 2));
	offset = K*strideB / 2 + N / 2;
	for (int i = 0; i < K / 2; i++)
	{
		for (int j = 0; j < N / 2; j++)
		{
			const int baseIdx = i*strideB + j;
			M1_1[i*N/2+j] = matB[baseIdx] + matB[baseIdx + offset];
		}
	}
	mm_strassen(&M1_0[0], &M1_1[0], &M1[0], M / 2, N / 2, K / 2,
		K/2,N/2,N/2);
}

//M2 = (A21+A22)*B11
std::vector<float> M2((M / 2) * (N / 2));
{
	memset(&M2[0], 0, M2.size()*sizeof(float));
	//M2_0 = (A21+A22)
	std::vector<float> M2_0((M / 2) * (K / 2));
	offset = K / 2;
	for (int i = M / 2; i < M; i++)
	{
		for (int j = 0; j < K / 2; j++)
		{
			const int baseIdx = i*strideA + j;
			M2_0[(i-M/2)*K/2+j] = matA[baseIdx] + matA[baseIdx + offset];
		}
	}
	//M2_2 = B11
	mm_strassen(&M2_0[0], &matB[N / 2], &M2[0], M / 2, N / 2, K / 2,
		K / 2, strideB, N / 2);
}

//M3 = A11*(B12-B22)
std::vector<float> M3((M / 2) * (N / 2));
{
	memset(&M3[0], 0, M3.size()*sizeof(float));
	//M3_0 = A11
	//M3_1 = (B12-B22)
	std::vector<float> M3_1((K / 2) * (N / 2));
	offset = K*strideB / 2;
	for (int i = 0; i < K/2; i++)
	{
		for (int j = N/2; j < N; j++)
		{
			const int baseIdx = i*strideB + j;
			M3_1[i*N/2+j-N/2] = matB[baseIdx] - matB[baseIdx + offset];
		}
	}
	mm_strassen(matA, &M3_1[0], &M3[0], M / 2, N / 2, K / 2,
		strideA, N / 2, N / 2);
}

//M4 = A22*(B21-B11)
std::vector<float> M4((M / 2) * (N / 2));
{
	memset(&M4[0], 0, M4.size()*sizeof(float));
	//M4_0 = A22
	//M4_1 = (B12-B22)
	std::vector<float> M4_1((K / 2) * (N / 2));
	offset = K*strideB / 2;
	for (int i = 0; i < K / 2; i++)
	{
		for (int j = N / 2; j < N; j++)
		{
			const int baseIdx = i*strideB + j;
			M4_1[i*N/2+j-N/2] = matB[baseIdx + offset] - matB[baseIdx];
		}
	}
	mm_strassen(matA + M*strideA / 2 + K / 2, &M4_1[0], &M4[0], M / 2, K / 2, N / 2,
		strideA, N / 2, N / 2);
}

//M5 = (A11+A12)*B22
std::vector<float> M5((M / 2) * (N / 2));
{
	memset(&M5[0], 0, M5.size()*sizeof(float));
	//M5_0 = (A11+A12)
	std::vector<float> M5_0((M / 2) * (K / 2));
	offset = K / 2;
	for (int i = 0; i < M/2; i++)
	{
		for (int j = 0; j < K / 2; j++)
		{
			const int baseIdx = i*strideA + j;
			M5_0[i*K / 2 + j] = matA[baseIdx] + matA[baseIdx + offset];
		}
	}
	//M5_1 = B22
	mm_strassen(&M5_0[0], &matB[K*strideB / 2 + N / 2], &M5[0], M / 2, N / 2, K / 2,
		K / 2, strideB, N / 2);
}

//M6 = (A21-A11)*(B11+B12)
std::vector<float> M6((M / 2) * (N / 2));
{
	memset(&M6[0], 0, M6.size()*sizeof(float));
	//M6_0 = (A21-A11)
	std::vector<float> M6_0((M / 2) * (K / 2));
	offset = K*N / 2;
	for (int i = 0; i < M / 2; i++)
	{
		for (int j = 0; j < K/2; j++)
		{
			const int baseIdx = i*strideA + j;
			M6_0[i*K/2+j] = matA[baseIdx + offset] - matA[baseIdx];
		}
	}
	//M6_1 = (B11+B12)
	std::vector<float> M6_1((K / 2) * (N / 2));
	offset = N / 2;
	for (int i = 0; i < K / 2; i++)
	{
		for (int j = 0; j < N/2; j++)
		{
			const int baseIdx = i*strideB + j;
			M6_1[i*N/2+j] = matB[baseIdx] + matB[baseIdx + offset];
		}
	}
	mm_strassen(&M6_0[0], &M6_1[0], &M6[0], M / 2, N / 2, K / 2,
		K / 2, N / 2, N / 2);
}

//M7 = (A12-A22)*(B21+B22)
std::vector<float> M7((M / 2) * (N / 2));
{
	memset(&M7[0], 0, M7.size()*sizeof(float));
	//M7_0 = (A12-A22)
	std::vector<float> M7_0((M / 2) * (K / 2));
	offset = M*strideA / 2;
	for (int i = 0; i < M / 2; i++)
	{
		for (int j = K/2; j < K; j++)
		{
			const int baseIdx = i*strideA + j;
			M7_0[i*K / 2 + j - K / 2] = matA[baseIdx] - matA[baseIdx + offset];
		}
	}
	//M7_1 = (B21+B22)
	std::vector<float> M7_1((K / 2) * (N / 2));
	offset = N / 2;
	for (int i = K/2; i < K; i++)
	{
		for (int j = 0; j < N / 2; j++)
		{
			const int baseIdx = i*strideB + j;
			M7_1[(i-K/2)*N / 2 + j] = matB[baseIdx] + matB[baseIdx + offset];
		}
	}
	mm_strassen(&M7_0[0], &M7_1[0], &M7[0], M / 2, N / 2, K / 2,
		K / 2, N / 2, N / 2);
}	
for (int i = 0; i < M / 2;i++)
{
	for (int j = 0; j < N / 2;j++)
	{
		const int idx = i*N / 2 + j;
		//C11 = M1+M4-M5+M7
		matC[i*strideC + j] = M1[idx] + M4[idx] - M5[idx] + M7[idx];
		//C12 = M3+M5
		matC[i*strideC + j + N/2] = M3[idx] + M5[idx];
		//C21 = M2+M4
		matC[(i+M/2)*strideC + j] = M2[idx] + M4[idx];
		//C22 = M1-M2+M3+M6
		matC[(i+M/2)*strideC + j + N/2] = M1[idx] - M2[idx] + M3[idx] + M6[idx];
	}
}

}
Coppersmith-Winograd算法
Coppersmith-Winograd算法，时间复杂度是O^2.38。定义见：wiki
c++实现：

static void mm_winograd(float* matA, float* matB, float* matC, const int M, const int N, const int K, const int strideA, const int strideB, const int strideC)
{
if ((M <= 64) || (M % 2 != 0 || N % 2 != 0 || K % 2 != 0))
{
return mm_generate(matA, matB, matC, M, N, K, strideA, strideB, strideC);
}
memset(matC, 0, MstrideCsizeof(float));
int offset = 0;

std::vector<float> S1((M / 2) * (K / 2));
std::vector<float> S2((M / 2) * (K / 2));
std::vector<float> S3((M / 2) * (K / 2));
std::vector<float> S4((M / 2) * (K / 2));
for (int i = 0; i < M / 2;i++)
{
	for (int j = 0; j < K / 2;j++)
	{
		const int idx = i*K / 2 + j;
		//S1 = A21 + A22
		S1[idx] = matA[(i + M / 2)*strideA + j] + matA[(i + M / 2)*strideA + j + K / 2];
		//S2 = S1 - A11
		S2[idx] = S1[idx] - matA[i*strideA + j];
		//S3 = A11 - A21
		S3[idx] = matA[i*strideA + j] - matA[(i + M / 2)*strideA + j];
		//S4 = A12 - S2
		S4[idx] = matA[i*strideA + j + K / 2] - S2[idx];
	}
}
std::vector<float> T1((K / 2) * (N / 2));
std::vector<float> T2((K / 2) * (N / 2));
std::vector<float> T3((K / 2) * (N / 2));	
std::vector<float> T4((K / 2) * (N / 2));
for (int i = 0; i < K / 2; i++)
{
	for (int j = 0; j < N / 2; j++)
	{
		const int idx = i*N / 2 + j;
		//T1 = B21 - B11
		T1[idx] = matB[(i + K / 2)*strideB + j] - matB[i*strideB + j];
		//T2 = B22 - T1
		T2[idx] = matB[(i + K / 2)*strideB + j + N / 2] - T1[idx];
		//T3 = B22 - B12
		T3[idx] = matB[(i + K / 2)*strideB + j + N / 2] - matB[i*strideB + j + N / 2];
		//T4 = T2 - B21
		T4[idx] = T2[idx] - matB[(i + K / 2)*strideB + j];
	}
}

//M1 = A11*B11
std::vector<float> M1((M / 2) * (N / 2));
{
	memset(&M1[0], 0, M1.size()*sizeof(float));
	mm_winograd(matA, matB, &M1[0], M / 2, N / 2, K / 2,
		strideA, strideB, N / 2);
}

//M2 = A12*B21
std::vector<float> M2((M / 2) * (N / 2));
{
	memset(&M2[0], 0, M2.size()*sizeof(float));
	mm_winograd(matA + K / 2, matB + K*strideB/2, &M2[0], M / 2, N / 2, K / 2,
		strideA, strideB, N / 2);
}

//M3 = S4*B22
std::vector<float> M3((M / 2) * (N / 2));
{
	memset(&M3[0], 0, M3.size()*sizeof(float));
	mm_winograd(&S4[0], matB + K*strideB/2 + N / 2, &M3[0], M / 2, N / 2, K / 2,
		K/2, strideB, N / 2);
}

//M4 = A22*T4
std::vector<float> M4((M / 2) * (N / 2));
{
	memset(&M4[0], 0, M4.size()*sizeof(float));
	mm_winograd(matA + M*strideA / 2 + K / 2, &T4[0], &M4[0], M / 2, N / 2, K / 2,
		strideA, N / 2, N / 2);
}

//M5 = S1*T1
std::vector<float> M5((M / 2) * (N / 2));
{
	memset(&M5[0], 0, M5.size()*sizeof(float));		
	mm_winograd(&S1[0], &T1[0], &M5[0], M / 2, N / 2, K / 2,
		K / 2, N/2, N / 2);
}

//M6 = S2*T2
std::vector<float> M6((M / 2) * (N / 2));
{
	memset(&M6[0], 0, M6.size()*sizeof(float));
	mm_winograd(&S2[0], &T2[0], &M6[0], M / 2, N / 2, K / 2,
		K / 2, N / 2, N / 2);
}

//M7 = S3*T3
std::vector<float> M7((M / 2) * (N / 2));
{
	memset(&M7[0], 0, M7.size()*sizeof(float));		
	mm_winograd(&S3[0], &T3[0], &M7[0], M / 2, N / 2, K / 2,
		K / 2, N / 2, N / 2);
}

for (int i = 0; i < M / 2; i++)
{
	for (int j = 0; j < N / 2; j++)
	{
		const int idx = i*N / 2 + j;
		//U1 = M1 + M2
		const auto U1 = M1[idx] + M2[idx];
		//U2 = M1 + M6
		const auto U2 = M1[idx] + M6[idx];
		//U3 = U2 + M7
		const auto U3 = U2 + M7[idx];
		//U4 = U2 + M5
		const auto U4 = U2 + M5[idx];
		//U5 = U4 + M3
		const auto U5 = U4 + M3[idx];
		//U6 = U3 - M4
		const auto U6 = U3 - M4[idx];
		//U7 = U3 + M5
		const auto U7 = U3 + M5[idx];

		//C11 = U1
		matC[i*strideC + j] = U1;
		//C12 = U5
		matC[i*strideC + j + N / 2] = U5;
		//C21 = U6
		matC[(i + M / 2)*strideC + j] = U6;
		//C22 = U7
		matC[(i + M / 2)*strideC + j + N / 2] = U7;
	}
}

}
其他优化方法
除了在时间复杂度上的优化以外，还可以通过多线程、SIMD指令、GPGPU等工程方法进行优化。

参考
http://www.cs.tau.ac.il/~zwick/Adv-Alg-2015/Matrix-Graph-Algorithms.pptx

我爱芹菜
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从零开始学RSA：已知dp,dq求解m和CopperSmith定理攻击
weixin_44626085的博客
04-10 1247
sage是基于python开发，所以python的语法几乎对它完全适用，但是sage自己还开发出了很多语法格式和数学公式，学习难度还是不低的，所以我把这些脚本都当做了工具，拿来直接用，自己写出来似乎能力还不够，因为不光要学语法，关键是这里面的数学算法知识。什么叫m的高位呢，很简单，比如题目给你m=0x65c46754a7776c8b88867e000000000000000000 前面的部分就是高位，后面的0就是低位，0只是占位的作用并不是真正m的值。要求出完整的m的值。
快速矩阵乘法的算法实现
qq_42327795的博客
03-10 1万+
快速矩阵乘法
矩阵相乘的快速算法
01-18 1649
http://dev.gameres.com/Program/Visual/3D/Mxquick.htm   
PCA图像压缩和重建
weixin_45587004的博客
09-09 1333
PCA进行图像压缩参考https://blog.csdn.net/program_developer/article/details/80632779 在新坐标系中得到了新坐标，即原文章中的 之后需要映射回原始坐标系，进行图像的重建
Strassen与Winograd快速矩阵乘法研究
02-24
Strassen与Winograd快速矩阵乘法研究
Winograd 变换
dengdengma520的博客
06-01 4238
原文地址：http://ncic.ac.cn/codesign/blog/?p=2565将一个2 X 3 的矩阵和一个3 X 1 的矩阵进行矩阵乘，我们可以用下面的公式表达：其中：原始的矩阵乘法需要6 次乘法，而winograd 只需要4 次。我们可以将上面的公式扩展到矩阵的表示：其中，* 符号表示矩阵元素乘（element-wise multiplication）。对于F(2; 3) 的情况，这...
strassen_矩阵乘法的strassen算法_
10-02
但由于其涉及较多的矩阵合并与分解，当n不是2的幂时需要额外的填充处理，且在实际应用中，当矩阵尺寸较小或者考虑到常数因子的影响，Strassen算法可能不如普通的矩阵乘法算法（如Coppersmith-Winograd算法）高效。...
java实现任意矩阵Strassen算法
09-02
当矩阵尺寸非常大时，Strassen算法的常数因子和内存开销可能会影响性能，因此在实际应用中，通常会结合其他优化策略，如Coppersmith-Winograd算法，或者在矩阵尺寸足够小的情况下切换回传统算法。
TestMatrix_多种C++矩阵乘法算法_avx_
09-29
2. **Coppersmith-Winograd算法**：理论上具有最小的时间复杂度，但在实践中，由于涉及到的系数过大，实际效率并不高。 3. **BLAS（Basic Linear Algebra Subprograms）库**：如OpenBLAS、MKL等，提供高度优化的...
juzhenchengfa.rar_快速 乘法_矩阵乘法 快速
09-14
快速乘法，通常指的是Strassen算法或Coppersmith-Winograd算法，这些算法通过分治策略来降低矩阵乘法的时间复杂度。传统的矩阵乘法算法，如高斯-约当消元法，其时间复杂度为O(n^3)，而快速乘法算法则可以将时间...
MATLAB工具箱大全-多维数据快速矩阵乘法
02-10
1. 矩阵乘法优化：MATLAB采用高效的算法进行矩阵乘法，如Strassen算法或Coppersmith-Winograd算法，使得大规模矩阵乘法速度显著提升。 2. 奇异值分解（SVD）与特征值分解（EVD）：这两种分解在数据分析和信号处理中...
深度学习（十一）——Winograd（1）
antkillerfarm的专栏
12-11 2万+
深度学习（十一）——Winograd（1）
WinoGrad算法
qq_41663008的博客
05-08 1750
WinoGrad算法 WinoGrad论文 计算背景-卷积计算方法   首先明确一点，这里说的卷积计算是指深度学习卷积网络（ConvNet）的计算方式，而不是高数中的卷积计算。目前常见的计算卷积的方式主要有以下集中方法： 滑动窗口：这种方法就是基本的计算方式，但是计算比较慢，因此一般不采用这种方法。 im2col：目前几乎所有的主流计算框架包括 Caffe, MXNet 等都实现了该方法。该方法把整个卷积过程转化成了 GEMM 过程，而 GEMM 在各种 BLAS 库中都是被极致优化的，一般来说，速度较快
程序员编程艺术第四十一章~四十二章：荷兰国旗、矩阵相乘Strassen算法
热门推荐
结构之法 算法之道
01-27 6万+
第四十一章~四十二章：荷兰国旗问题、矩阵相乘之Strassen算法前言    本文要讲的两个问题：荷兰国旗和矩阵相乘之Strassen算法 都跟分治法相关，故把这两个问题放到了一起。所谓分治，便是分而治之的意思，好比打战时面对敌人的庞大武装，采取避其主力，各个击破的策略。    有何问题，欢迎随时不吝指正，thanks。第十一章、荷兰国旗问题题目描述现有红白蓝三个不同颜色的小球，乱序排列在一起，请
知识 ：卷积神经网络性能优化
数据分析
04-15 679
转自：AI蜗牛车、极市平台作者丨黎明灰烬来源｜https://zhuanlan.zhihu.com/p/80361782引言卷积（Convolution）是神经网络的核心计算之一，它在计算机视觉方面的突破性进展引领了深度学习的热潮。卷积的变种丰富，计算复杂，神经网络运行时大部分时间都耗费在计算卷积，网络模型的发展在不断增加网络的深度，因此优化卷积计算就显得尤为重要。随着技...
通用矩阵乘（GEMM）优化算法从入门到实践
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
10-13 1329
矩阵乘的算法优化可分为两类：基于算法分析的方法：根据矩阵乘计算特性，从数学角度优化，典型的算法包括 Strassen 算法和 Coppersmith–Winograd 算法。基于软件优化的方法：根据计算机存储系统的层次结构特性，选择性地调整计算顺序，主要有循环拆分向量化、内存重排等。
5分钟掌握矩阵乘法的Strassen算法
TCP/IP协议栈学习ing
08-18 2253
By LongLuo 机器学习中需要训练大量数据，涉及大量复杂运算，例如卷积、矩阵等。这些复杂运算不仅多，而且每次计算的数据量很大，如果能针对这些运算进行优化，可以大幅提高性能。 一、矩阵乘法 假设AAA为m×pm \times pm×p的矩阵，BBB为p×np \times np×n的矩阵，那么称m×nm \times nm×n的矩阵CCC为矩阵AAA与BBB的乘积，记作C=ABC = ABC=...
分治算法中的可优化点(三)
liao_hb的专栏
04-29 2783
你的打赏是我奋笔疾书的动力！​ 这一节来聊一聊，老生常谈的2个优化。 优化分治算法，单从降低时间复杂度的角度出发，也就是从分治算法的时间复杂度的递推公式出发，W(n)=aW(n/b)+d(n)，有以下二种途径： 途径一：降低a的数值，减少子问题的个数 减少子问题数量的策略是有前提的，具体分析如下： 若这个分治算法的时间复杂度递推式满足主定理的第一个结论的条件，那么...
coppersmith–winograd 算法
最新发布
03-16
Coppersmith-Winograd算法是一种用于矩阵乘法的算法，它的时间复杂度为O(n^2.376)，比传统的Strassen算法更快。该算法由Don Coppersmith和Shmuel Winograd于199年提出。它的主要思想是通过分治和递归的方式将矩阵...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值