矩阵相乘的三种方法（java实现）

最新推荐文章于 2024-01-27 11:24:02 发布
最新推荐文章于 2024-01-27 11:24:02 发布
阅读量9.6k 收藏 8
点赞数 1
分类专栏： 算法笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cqy_chen/article/details/24229343
版权
package cqychen.algorithm.ch01;

/**
 * 本程序由cqychen编写，主要是矩阵相乘的三种方法， 常规方法，一般的分治算法，strassen算法,这里就不编写泛型的相关方法了，麻烦。
 * 后续会继续跟进算法导论相应章节 如有任何问题发送意见至chen_yu_qin_g@163.com
 * 
 * ***strassen算法只能是两个矩阵都是方阵且其行数是2的幂
 * @author cqychen
 * 
 */
class MatrixMultiple {
// 设置输入输出变量
private Integer[][] a;
private Integer[][] b;
private Integer[][] c;// 用于保存通过普通的矩阵相乘得到结果
private Integer[][] cd;// 用于保存通过普通分治发得到的结果
private Integer[][] cds;// 用于保存通过strassen算法得到的结果

// 构造函数，传入外界的a和b
public MatrixMultiple(Integer[][] a, Integer[][] b) {
super();
this.a = a;
this.b = b;
this.c = new Integer[a.length][b[0].length];
this.cd = new Integer[a.length][b[0].length];
this.cds = new Integer[a.length][b[0].length];
}
//编写两个矩阵相加的函数
private Integer[][] MatrixAdd(Integer[][]a,Integer[][]b){
Integer a1 = a.length;
Integer a2 = a[0].length;
Integer b1 = b.length;
Integer b2 = b[0].length;
Integer[][] c = new Integer[a1][a2];
if(a1!=b1||a2!=b2){
System.out.println("两个矩阵的行数或者列数不相等，不能进行相加");
}
for(Integer i=0;i<a1;i++){
for(Integer j=0;j<a2;j++){
c[i][j] = a[i][j]+b[i][j];
}
}
return c;
}
//编写两个矩阵相减的函数
private Integer[][] MatrixMinus(Integer[][]a,Integer[][]b){
Integer a1 = a.length;
Integer a2 = a[0].length;
Integer b1 = b.length;
Integer b2 = b[0].length;
Integer[][] c = new Integer[a1][a2];
if(a1!=b1||a2!=b2){
System.out.println("两个矩阵的行数或者列数不相等，不能进行相减");
}
for(Integer i=0;i<a1;i++){
for(Integer j=0;j<a2;j++){
c[i][j] = a[i][j]-b[i][j];
}
}
return c;
}
/**
 * 采用传统的矩阵相乘的算法,此函数也会作为其余两个方法的调用函数
 * 
 * @param a
 *            ,这个a指的是局部方法里面的a
 * @param b
 *            ，这个b指的是局部方法的b
 * @return
 */
private Integer[][] NormalCal(Integer[][] a, Integer[][] b) {
Integer lena1 = a.length;// 得到a的行数
Integer lena2 = a[0].length;// 得到a的列数
Integer lenb1 = b.length;// 这个值应该和a的列数一样
Integer lenb2 = b[0].length;// 得到b的列数
Integer[][] c = new Integer[a.length][b[0].length];
for (Integer i = 0; i < lena1; i++) {
for (Integer j = 0; j < lenb2; j++) {
Integer sum = 0;
for (Integer k = 0; k < lena2; k++) {
sum += a[i][k] * b[k][j];
}
c[i][j] = sum;
}
}
return c;
}

/**
 * 这里将采用传统的分治方法实现，与strassen算法进行一个对比
 * 这里可以采用坐标的方式，但是如果使用坐标，将会传入aa、bb的计算坐标点,我觉得麻烦，但是应该这样做，因为这样的话，不用赋值操作了
 */
private Integer[][] DevideNormal(Integer[][] aa,Integer[][] bb){
Integer lenaa1 = aa.length;// 得到a的行数
Integer lenaa2 = aa[0].length;// 得到a的列数
Integer lenbb1 = bb.length;// 这个值应该和a的列数一样,只是保留在这里不用
Integer lenbb2 = bb[0].length;// 得到b的列数
Integer[][] cc = new Integer[lenaa1][lenbb2];
//如果aa的行数或者aa的列数（等于bb的行数）或者bb的列数为1，即停止进行分解。
if(lenaa1==1||lenaa2==1||lenbb2==1){
cc = NormalCal(aa, bb);
return cc;
}
//构造最后得到的cc数组的四个分块矩阵
Integer c111 = lenaa1/2;
Integer c112 = lenbb2/2;
Integer c121 = lenaa1/2;
Integer c122 = (lenbb2+1)/2;
Integer c211 = (lenaa1+1)/2;
Integer c212 = lenbb2/2;
Integer c221 = (lenaa1+1)/2;
Integer c222 = (lenbb2+1)/2;
Integer[][] c11 = new Integer[c111][c112];
Integer[][] c12 = new Integer[c121][c122];
Integer[][] c21 = new Integer[c211][c212];
Integer[][] c22 = new Integer[c221][c222];
//一下四个数组分别存放aa的划分的四个部分lena111表示aa第一个分块矩阵a11的行数
Integer lena111 = lenaa1/2;//记录aa矩阵分块的第一个矩阵的行数
Integer lena112 = lenaa2/2;//记录aa矩阵分块的第一个矩阵的列数
Integer lena121 = lenaa1/2;//以下类似
Integer lena122 = (lenaa2+1)/2;
Integer lena211 = (lenaa1+1)/2;
Integer lena212 = lenaa2/2;
Integer lena221 = (lenaa1+1)/2;
Integer lena222 = (lenaa2+1)/2;
Integer[][] a11 = new Integer[lenaa1/2][lenaa2/2];
Integer[][] a12 = new Integer[lenaa1/2][(lenaa2+1)/2];
Integer[][] a21 = new Integer[(lenaa1+1)/2][lenaa2/2];
Integer[][] a22 = new Integer[(lenaa1+1)/2][(lenaa2+1)/2];
//进行初始化操作
Integer i=0;
Integer j=0;
for(i=0;i<lena111;i++){
for(j=0;j<lena112;j++){
a11[i][j] = aa[i][j];
}
}
for(i=0;i<lena121;i++){
for(j=0;j<lena122;j++){
a12[i][j] = aa[i][j+lena112];
}
}
for(i=0;i<lena211;i++){
for(j=0;j<lena212;j++){
a21[i][j] = aa[i+lena111][j];
}
}
for(i=0;i<lena221;i++){
for(j=0;j<lena222;j++){
a22[i][j] = aa[i+lena111][j+lena112];
}
}
//以下四个数组分别存放bb划分的四个部分
Integer lenb111 = lenbb1/2;//记录aa矩阵分块的第一个矩阵的行数
Integer lenb112 = lenbb2/2;//记录aa矩阵分块的第一个矩阵的列数
Integer lenb121 = lenbb1/2;//以下类似
Integer lenb122 = (lenbb2+1)/2;
Integer lenb211 = (lenbb1+1)/2;
Integer lenb212 = lenbb2/2;
Integer lenb221 = (lenbb1+1)/2;
Integer lenb222 = (lenbb2+1)/2;
Integer[][] b11 = new Integer[lenb111][lenb112];
Integer[][] b12 = new Integer[lenb121][lenb122];
Integer[][] b21 = new Integer[lenb211][lenb212];
Integer[][] b22 = new Integer[lenb221][lenb222];
for(i=0;i<lenb111;i++){
for(j=0;j<lenb112;j++){
b11[i][j] = bb[i][j];
}
}
for(i=0;i<lenb121;i++){
for(j=0;j<lenb122;j++){
b12[i][j] = bb[i][j+lenb112];
}
}
for(i=0;i<lenb211;i++){
for(j=0;j<lenb212;j++){
b21[i][j] = bb[i+lenb111][j];
}
}
for(i=0;i<lenb221;i++){
for(j=0;j<lenb222;j++){
b22[i][j] = bb[i+lenb111][j+lenb112];
}
}
//DevideNormal();
//递归调用以解决问题
/*printMatrix(a12);
printMatrix(b21);
printMatrix(DevideNormal(a12, b21));*/
c11=MatrixAdd(DevideNormal(a11, b11), DevideNormal(a12, b21));
c12=MatrixAdd(DevideNormal(a11, b12), DevideNormal(a12, b22));
c21=MatrixAdd(DevideNormal(a21, b11), DevideNormal(a22, b21));
c22=MatrixAdd(DevideNormal(a21, b12), DevideNormal(a22, b22));
for(i=0;i<c111;i++){
for(j=0;j<c112;j++){
cc[i][j] = c11[i][j];
}
}
for(i=0;i<c121;i++){
for(j=0;j<c122;j++){
cc[i][j+c112] = c12[i][j];
}
}
for(i=0;i<c211;i++){
for(j=0;j<c212;j++){
cc[i+c111][j] = c21[i][j];
}
}
for(i=0;i<c221;i++){
for(j=0;j<c222;j++){
cc[i+c111][j+c112] = c22[i][j];
}
}
return cc;
}

/**
 * 这里采用strassen算法，strassen算法和普通的分治法实现在前面都是一样的，进行划分，
 * 主要是后面的做法，只进行了7次乘法同事进行了10次加减法
 * @param aa
 * @param bb
 * @return
 */
private Integer[][] Strassen(Integer[][] aa,Integer[][]bb){
Integer lenaa1 = aa.length;// 得到a的行数
Integer lenaa2 = aa[0].length;// 得到a的列数
Integer lenbb1 = bb.length;// 这个值应该和a的列数一样,只是保留在这里不用
Integer lenbb2 = bb[0].length;// 得到b的列数
Integer[][] cc = new Integer[lenaa1][lenbb2];
//如果aa的行数或者aa的列数（等于bb的行数）或者bb的列数为1，即停止进行分解。
if(lenaa1==1||lenaa2==1||lenbb2==1){
cc = NormalCal(aa, bb);
return cc;
}
if(lenaa1!=lenaa2||lenaa1!=lenbb1||lenbb1!=lenbb2||lenaa1%2!=0){
System.out.println("不能进行strassen算法，strassen算法只能是两个矩阵都是方阵"
+ "且其行数是2的幂");
return cc;
}
//构造最后得到的cc数组的四个分块矩阵
Integer c111 = lenaa1/2;
Integer c112 = lenbb2/2;
Integer c121 = lenaa1/2;
Integer c122 = (lenbb2+1)/2;
Integer c211 = (lenaa1+1)/2;
Integer c212 = lenbb2/2;
Integer c221 = (lenaa1+1)/2;
Integer c222 = (lenbb2+1)/2;
Integer[][] c11 = new Integer[c111][c112];
Integer[][] c12 = new Integer[c121][c122];
Integer[][] c21 = new Integer[c211][c212];
Integer[][] c22 = new Integer[c221][c222];
//一下四个数组分别存放aa的划分的四个部分lena111表示aa第一个分块矩阵a11的行数
Integer lena111 = lenaa1/2;//记录aa矩阵分块的第一个矩阵的行数
Integer lena112 = lenaa2/2;//记录aa矩阵分块的第一个矩阵的列数
Integer lena121 = lenaa1/2;//以下类似
Integer lena122 = (lenaa2+1)/2;
Integer lena211 = (lenaa1+1)/2;
Integer lena212 = lenaa2/2;
Integer lena221 = (lenaa1+1)/2;
Integer lena222 = (lenaa2+1)/2;
Integer[][] a11 = new Integer[lenaa1/2][lenaa2/2];
Integer[][] a12 = new Integer[lenaa1/2][(lenaa2+1)/2];
Integer[][] a21 = new Integer[(lenaa1+1)/2][lenaa2/2];
Integer[][] a22 = new Integer[(lenaa1+1)/2][(lenaa2+1)/2];
//进行初始化操作
Integer i=0;
Integer j=0;
for(i=0;i<lena111;i++){
for(j=0;j<lena112;j++){
a11[i][j] = aa[i][j];
}
}
for(i=0;i<lena121;i++){
for(j=0;j<lena122;j++){
a12[i][j] = aa[i][j+lena112];
}
}
for(i=0;i<lena211;i++){
for(j=0;j<lena212;j++){
a21[i][j] = aa[i+lena111][j];
}
}
for(i=0;i<lena221;i++){
for(j=0;j<lena222;j++){
a22[i][j] = aa[i+lena111][j+lena112];
}
}
//以下四个数组分别存放bb划分的四个部分
Integer lenb111 = lenbb1/2;//记录aa矩阵分块的第一个矩阵的行数
Integer lenb112 = lenbb2/2;//记录aa矩阵分块的第一个矩阵的列数
Integer lenb121 = lenbb1/2;//以下类似
Integer lenb122 = (lenbb2+1)/2;
Integer lenb211 = (lenbb1+1)/2;
Integer lenb212 = lenbb2/2;
Integer lenb221 = (lenbb1+1)/2;
Integer lenb222 = (lenbb2+1)/2;
Integer[][] b11 = new Integer[lenb111][lenb112];
Integer[][] b12 = new Integer[lenb121][lenb122];
Integer[][] b21 = new Integer[lenb211][lenb212];
Integer[][] b22 = new Integer[lenb221][lenb222];
for(i=0;i<lenb111;i++){
for(j=0;j<lenb112;j++){
b11[i][j] = bb[i][j];
}
}
for(i=0;i<lenb121;i++){
for(j=0;j<lenb122;j++){
b12[i][j] = bb[i][j+lenb112];
}
}
for(i=0;i<lenb211;i++){
for(j=0;j<lenb212;j++){
b21[i][j] = bb[i+lenb111][j];
}
}
for(i=0;i<lenb221;i++){
for(j=0;j<lenb222;j++){
b22[i][j] = bb[i+lenb111][j+lenb112];
}
}
//下面开始strassen的递归调用
//首先构造10个矩阵s1~s10
Integer[][] s1 = MatrixMinus(b12, b22);
Integer[][] s2 = MatrixAdd(a11, a12);
Integer[][] s3 = MatrixAdd(a21,a22);
Integer[][] s4 = MatrixMinus(b21, b11);
Integer[][] s5 = MatrixAdd(a11, a22);
Integer[][] s6 = MatrixAdd(b11, b22);
Integer[][] s7 = MatrixMinus(a12, a22);
Integer[][] s8 = MatrixAdd(b21, b22);
Integer[][] s9 = MatrixMinus(a11, a21);
Integer[][] s10 = MatrixAdd(b11, b12);
//进行七次递归相乘
Integer[][] p1 = Strassen(a11, s1);
Integer[][] p2 = Strassen(s2, b22);
Integer[][] p3 = Strassen(s3, b11);
Integer[][] p4 = Strassen(a22, s4);
Integer[][] p5 = Strassen(s5, s6);
Integer[][] p6 = Strassen(s7, s8);
Integer[][] p7 = Strassen(s9, s10);
c11 = MatrixAdd(MatrixMinus(MatrixAdd(p5, p4), p2),p6);
c12 = MatrixAdd(p1, p2);
c21 = MatrixAdd(p3, p4);
c22 = MatrixMinus(MatrixAdd(p5, p1), MatrixAdd(p3, p7));
for(i=0;i<c111;i++){
for(j=0;j<c112;j++){
cc[i][j] = c11[i][j];
}
}
for(i=0;i<c121;i++){
for(j=0;j<c122;j++){
cc[i][j+c112] = c12[i][j];
}
}
for(i=0;i<c211;i++){
for(j=0;j<c212;j++){
cc[i+c111][j] = c21[i][j];
}
}
for(i=0;i<c221;i++){
for(j=0;j<c222;j++){
cc[i+c111][j+c112] = c22[i][j];
}
}
return cc;
}
// 将得到的c进行输出
public void print() {
//这是调用普通的算法
System.out.println("这是调用普通的算法");
this.c = NormalCal(this.a, this.b);
printMatrix(c);
System.out.println("这是调用普通的分治算法");
this.cd = DevideNormal(this.a, this.b);
printMatrix(cd);
System.out.println("这里调用strassen算法");
this.cds = Strassen(this.a, this.b);
printMatrix(cds);
}

public void printMatrix(Integer[][] c) {
for (Integer i = 0; i < c.length; i++) {
for (Integer j = 0; j < c[0].length; j++) {
System.out.print(c[i][j] + " ");
}
System.out.println();
}
}
}

public class Strassen {
public static void main(String[] args) {
System.out.println("本程序主要用于演示stassen算法");
Integer[][] a = new Integer[][] { { 1, 0, 1 }, { 0, 0, 1 },
{ 1, 0, 0 }, { 1, 1, 1 }, { 0, 1, 0 } };
Integer[][] b = new Integer[][] { { 1, 0, 1, 0, 1, 1, 0 },
{ 0, 1, 1, 0, 1, 0, 1 }, { 1, 0, 1, 1, 0, 0, 1 } };
if (a[0].length != b.length) {
System.out.println("a的行数与b的列数不一致，不能进行计算");
return;
}// 如果a行数与b的列数不一致，那么直接返回不能进行计算
// 调用常规的函数进行计算
MatrixMultiple matrixmultiple = new MatrixMultiple(a, b);
matrixmultiple.print();
}
}

cqychen
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用java实现矩阵的转置和矩阵的相乘
03-20
用java实现矩阵的转置和矩阵的相乘，就是一个很简单的小程序，初次学java，试着编的，比较简单，仅供参考
strassen矩阵乘法 java_分治法-Strassen矩阵乘法
weixin_42525005的博客
02-22 549
算法思想：分治法 实际问题：Strassen 矩阵乘法 编写语言：Java问题描述我们知道，两个大小为 2 * 2 的矩阵相乘，一般需要进行 8 次乘法。而Strassen矩阵乘法可以减少一次乘法，只需要 7 次，看似很少，但当数据量很大时，效率就会有显著提升。不过使用 Strassen矩阵乘法需要满足 矩阵边长为 2 的幂次方。因为该算法会用到分治，如果分治后矩阵两边边长不等，结果会出错。使用下...
Java实现矩阵乘法
最新发布
Spell a的博客
01-27 236
3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。1、当矩阵A的列数（column）等于矩阵B的行数（row）时，A与B可以相乘。2、矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。
分治法--Strassen矩阵乘法
weixin_44721537的博客
02-01 1064
1）问题描述 就是将俩个正方形矩阵进行相乘，本来直接3个for就可以完成，但是由于时间复杂度的问题改进成了Strassen方法。 2）基本思路 就是用Strassen方法将矩阵进行分解，然后递归求。 3）代码实现 package laoya; import java.lang.Math; import java.util.Arrays; import java.util.Scanner; pu...
分治法解决矩阵乘法问题
山风不打咩的博客
05-11 2402
分治法解决矩阵乘法问题 传统for循环： #include<iostream> #include<cstdio> #include <vector> #include<algorithm> using namespace std; int n, m, p; int main() { printf("第一个n×m矩阵？\n"); cin >> n >> m; vector<vector<int>> A(n,
实现两个矩阵相乘（Java）
qq_45104603的博客
03-23 6724
矩阵乘法（Java实现） 矩阵可以用二维数组来表示：比如arr[n][m],其中n表示矩阵的行数m代表矩阵的列数,根据矩阵相乘的特性，两个矩阵相乘生成的那个新矩阵的行列是第一个矩阵的行和第二个矩阵的列，为了方便大家理解我这里就举一个例子： 比如两个矩阵*arr1[n][m]arr2[m][k]=arr3[n][k]。 至此我们可以写出代码: import java.util.Scanner; p...
java实现俩个矩阵的相乘
WvemiL9的博客
11-09 2503
import java.util.Scanner; public class juzhen { public static void main(String[] args) { Scanner in = new Scanner(System.in); System.out.print("请输入第一个矩阵的二维数据："); int n1 = in.nextInt(); int m1 = in.nextInt(); in.
Java实现矩阵相乘问题
南 墙
07-15 2万+
1 问题描述 1.1实验题目 设M1和M2是两个n×n的矩阵，设计算法计算M1×M2 的乘积。 1.2实验目的 （1）提高应用蛮力法设计算法的技能； （2）深刻理解并掌握分治法的设计思想； （3）理解这样一个观点：用蛮力法设计的算法，一般来说，经过适度的努力后，都可以对其进行改进，以提高算法的效率。 1.3实验要求 （1）设计并实现用BF(Brute-Force，即蛮力法)方法求解矩阵相乘问题...
编写两个矩阵相乘的方法（Java）
JC_ZQ_Fighting的博客
04-17 2809
方法头如下： public static double[][] multiplyMatrix(double[][] a, double[][] b) 为了使矩阵a能够和矩阵b相乘，矩阵a的列数必须与矩阵b的行数相同，并且两个矩阵的元素要具有相同或兼容的数据类型。假设矩阵c是相乘的结果，而a的列数是n，那么每个元素c[ij]=a[i1]*b[1j]+······+a[in]*b[nj]。 编写一个测试程序，提示用户输入两个3*3的矩阵，然后显示它们的乘积。 import java.util.Sc.
Java实现矩阵相乘
ly's Blog
07-12 2万+
首先我们要知道二维数组就是类似于我们线性代数中的矩阵，矩阵的乘法运算大概是这样满足条件，第一个矩阵的列数等于第二个矩阵的行数 由两个矩阵相乘的矩阵的每一个元素是由第一个矩阵每一行元素分别乘上第二个矩阵的列 对应的元素在相加 当矩阵A的列数等于矩阵B的行数时，A与B可以相乘。矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素...
Java设计两个矩阵相乘的方法
热门推荐
隔壁好叔叔
11-13 2万+
编写二个矩阵相乘的方法，方法头为： public static double[][] multiplyMatrix(double[][] a,double[][] b) 这里a的列数必须等于b的行数。 要求：提示输入m*n的矩阵a和n*k的矩阵b,m、n、k的值由用户输入，a和b的元素也由用户输入。显示a*b的结果矩阵。
java编程实现两个任意的矩阵相乘
12-22
实现自由输入规范的两个矩阵相乘，能够很好的实现这个功能
两个矩阵相乘的算法之java
04-02
java编写的两个矩阵相乘的算法，打包文件，class
java 矩阵乘法的mapreduce程序实现
08-30
主要介绍了java 矩阵乘法的mapreduce程序实现的相关资料,需要的朋友可以参考下
java实现矩阵的基本运算。
04-09
该程序实现了Java的基本运算： 1.矩阵的相加。 2.矩阵的相减。 3.矩阵于数的相乘。 4.矩阵于矩阵的相乘。 5.矩阵的求秩。 6.矩阵的求逆（能求2阶以上的）。 7.矩阵的转秩。
Java实现的矩阵乘法示例
08-26
主要介绍了Java实现的矩阵乘法,简单描述了矩阵乘法的原理,并结合实例形式分析了java实现矩阵乘法的相关操作技巧,需要的朋友可以参考下
Java实现张量相乘（tensorflow）
10-09
Java实现张量相乘（tensorflow）
python实现二叉树的俯视图
小猪观察家
01-20 2403
概要： 给一个二叉树，代码实现输出俯视图，如： 代码实现： #coding=utf8 #构造树节点 ''' 基本思想： 对于每个节点输出关于根节点的层级和左右距离 树从0层开始计数 左距离：左子树上节点对于跟节点为1 右距离：右字数上节点对于跟节点为-1 相当于以树的根节点为坐标原点，每个树中的节点对应一个坐标轴 横轴表示距离，纵轴表示树的深度 树的俯视图即输出：这些点映射到横轴上，
用java实现矩阵相乘
06-02
以下是Java实现矩阵相乘的示例代码： ```java public class MatrixMultiplication { public static void main(String[] args) { int[][] matrixA = { { 1, 2, 3 }, { 4, 5, 6 } }; int[][] matrixB = { { 7, 8 }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值