矩阵倍增 学习总结

最新推荐文章于 2024-05-08 08:55:35 发布
最新推荐文章于 2024-05-08 08:55:35 发布
阅读量231 收藏
点赞数
原文链接：http://www.cnblogs.com/joyouth/p/5539655.html
版权

所谓矩阵倍增，就是考试的时候学习的一种新技巧

从字面上就可以理解，利用倍增思想求得我们所需要的矩阵

理论基础是 矩阵满足结合律和分配率

 

UVa 11149

裸题，给定矩阵T，求T^1+……+T^n的矩阵

我们都知道利用倍增我们很容易求出T^i (i=2^k)的矩阵，时间复杂度是O(m^3logn)

我们定义一个矩阵为F(k)=T^1+……+T^(2^k)，定义G(k)=T^(2^k)

不难发现F(k+1)=F(k)+F(k)*G(k),G(k+1)=G(k)*G(k)

之后我们用类似快速幂的方式将n分解，当第k位是1的时候我们计算一下F(k)的贡献并加入答案

时间复杂度O(m^3logn),常数略大

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;

const int mod=10;
int n,k;
struct Matrix{
	int a[42][42];
	void clear(){memset(a,0,sizeof(a));}
	void print(){
		for(int i=1;i<=n;++i){
			for(int j=1;j<=n;++j){
				printf("%d",a[i][j]);
				if(j==n)printf("\n");
				else printf(" ");
			}
		}printf("\n");
	}
}A,B,C,I,ans,base;

Matrix operator *(const Matrix &A,const Matrix &B){
	Matrix C;C.clear();
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			for(int k=1;k<=n;++k){
				C.a[i][j]=C.a[i][j]+A.a[i][k]*B.a[k][j];
			}C.a[i][j]%=mod;
		}
	}return C;
}
Matrix operator +(const Matrix &A,const Matrix &B){
	Matrix C;C.clear();
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			C.a[i][j]=A.a[i][j]+B.a[i][j];
			if(C.a[i][j]>=mod)C.a[i][j]-=mod;
		}
	}return C;
}
void Solve(int p){
	B=A;C=A;ans.clear();base=I;
	while(p){
		if(p&1){
			ans=ans+B*base;
			base=base*C;
		}
		B=B+B*C;
		C=C*C;p>>=1;
	}return;
}

int main(){
	while(scanf("%d%d",&n,&k)==2){
		if(!n)break;
		for(int i=1;i<=n;++i){
			for(int j=1;j<=n;++j){
				scanf("%d",&A.a[i][j]);	
				A.a[i][j]%=mod;			
			}
		}
		I.clear();
		for(int i=1;i<=n;++i)I.a[i][i]=1;
		Solve(k);
		ans.print();
	}return 0;
}

5.25考试题T1

我们也是要求A^0+……+A^(n-1)

当时我的做法是利用等比数列求和和矩阵求逆搞一搞搞出来的

实际上那道题目也可以写矩阵倍增水过去

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<cstring>
using namespace std;
 
typedef long long LL;
const int mod=1e9+7;
int T,n,k;
struct Matrix{
    LL a[2][2];
    void clear(){memset(a,0,sizeof(a));}
}A,B,C,base,ans,I,Ans;
 
Matrix operator *(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=0;i<2;++i){
        for(int j=0;j<2;++j){
            for(int k=0;k<2;++k){
                C.a[i][j]=C.a[i][j]+A.a[i][k]*B.a[k][j]%mod;
                if(C.a[i][j]>=mod)C.a[i][j]-=mod;
            }
        }
    }return C;
}
Matrix operator +(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=0;i<2;++i){
        for(int j=0;j<2;++j){
            C.a[i][j]=A.a[i][j]+B.a[i][j];
            if(C.a[i][j]>=mod)C.a[i][j]-=mod;
        }
    }return C;
}
void Solve(int p){
    B=A;C=A;base=I;ans=I;
    while(p){
        if(p&1){
            ans=ans+B*base;
            base=base*C;
        }
        B=B+B*C;
        C=C*C;p>>=1;
    }return;
}
Matrix pow_mod(Matrix v,int p){
    Matrix tmp=I;
    while(p){
        if(p&1)tmp=tmp*v;
        v=v*v;p>>=1;
    }return tmp;
}
 
int main(){
    scanf("%d",&T);
    A.a[1][0]=A.a[0][1]=A.a[1][1]=1;
    I.a[0][0]=I.a[1][1]=1;
    while(T--){
        scanf("%d%d",&n,&k);
        if(n==1){printf("1\n");continue;}
        n--;Solve(n);
        ans=pow_mod(ans,k);
        Ans.clear();Ans.a[0][1]=1;
        Ans=Ans*ans;
        printf("%lld\n",Ans.a[0][1]);
    }return 0;
}

BZOJ 杰杰的女性朋友

这道题目在BZOJ双倍经验QAQ，还有一道是Graph。。

首先我们把out写成一个n*k的矩阵，然后把in反过来写成k*n的矩阵

题目中的一坨东西显然是一堆向量的线性组合，那么用这样的矩阵描述可以得到

邻接矩阵G=out*in,那么路径恰好为d的条数的矩阵就是G^d

也就是(out*in)^d，我们发现out*in得到的是n*n的矩阵，而in*out得到的是k*k的矩阵

n<=1000，k<=20，所以利用结合律，我们可以把式子写成out*(in*out)^(d-1)*in

然后因为要求<=d的总和，定义T=in*out

根据分配率可以得到out*(T^1+T^2+……+T^(d-1))*in

中间部分利用矩阵倍增即可，最后注意判断u==v

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cstdlib>
using namespace std;
 
typedef long long LL;
const int mod=1e9+7;
int n,m,K,u,v,d;
LL out[1010][22],in[22][1010];
LL tmp[1010][22];
struct Matrix{
    LL a[22][22];
    void clear(){memset(a,0,sizeof(a));}
}A,B,C,I,base,ans;
 
void read(LL &num){
    num=0;char ch=getchar();
    while(ch<'!')ch=getchar();
    while(ch>='0'&&ch<='9')num=num*10+ch-'0',ch=getchar();
    num%=mod;
}
Matrix operator *(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=1;i<=K;++i){
        for(int j=1;j<=K;++j){
            for(int k=1;k<=K;++k){
                C.a[i][j]=C.a[i][j]+A.a[i][k]*B.a[k][j]%mod;
                if(C.a[i][j]>=mod)C.a[i][j]-=mod;
            }
        }
    }return C;
}
Matrix operator +(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=1;i<=K;++i){
        for(int j=1;j<=K;++j){
            C.a[i][j]=A.a[i][j]+B.a[i][j];
            if(C.a[i][j]>=mod)C.a[i][j]-=mod;
        }
    }return C;
}
void Get_ans(int p){
    B=A;C=A;ans=I;base=I;
    while(p){
        if(p&1){
            ans=ans+B*base;
            base=base*C;
        }
        B=B+B*C;
        C=C*C;p>>=1;
    }return;
}
 
int main(){
    scanf("%d%d",&n,&K);
    for(int i=1;i<=n;++i){
        for(int j=1;j<=K;++j)read(out[i][j]);
        for(int j=1;j<=K;++j)read(in[j][i]);
    }
    for(int i=1;i<=K;++i){
        for(int j=1;j<=K;++j){
            for(int k=1;k<=n;++k){
                A.a[i][j]=A.a[i][j]+in[i][k]*out[k][j]%mod;
                if(A.a[i][j]>=mod)A.a[i][j]-=mod;
            }
        }
    }
    for(int i=1;i<=K;++i)I.a[i][i]=1;
    scanf("%d",&m);
    while(m--){
        scanf("%d%d%d",&u,&v,&d);
        if(d==0){printf("%d\n",(u==v?1:0));continue;}
        d--;Get_ans(d);
        for(int i=1;i<=n;++i){
            for(int j=1;j<=K;++j){
                tmp[i][j]=0;
                for(int k=1;k<=K;++k){
                    tmp[i][j]=tmp[i][j]+out[i][k]*ans.a[k][j]%mod;
                    if(tmp[i][j]>=mod)tmp[i][j]-=mod;
                }
            }
        }
        LL S=0;
        for(int i=1;i<=K;++i){
            S=S+tmp[u][i]*in[i][v]%mod;
            if(S>=mod)S-=mod;
        }
        if(u==v)S++;
        if(S>=mod)S-=mod;
        printf("%lld\n",S);
    }return 0;
}

BZOJ 林中路径

题目翻译过来是求sigma(i^2*T^i)

首先如果没有i^2我们是会做的，我们不妨先考虑i*T^i的情况

定义A(i)=T^i,B(i)=i*T^i

不难发现B(i) = (i-j)*T^i+j*T^i = ((i-j)*T^(i-j)*T^j)+(j*T^j*T^(i-j))

也就是B(i) = B(i-j)*A(j) + B(j)*A(i-j)

这样我们定义C(i)=i^2*T^i

同理推导一下可以得到

C(i) = C(i-j)*A(j) + C(j)*A(i-j) +2*B(j)*B(i-j)

然后我们求sigma用矩阵倍增搞一搞就可以了

不小心把ik*kj写成了ij*jk调了一个多小时QAQ

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
 
typedef long long LL;
int n,m,k,q,u,v;
const int mod=1e9+7;
struct Matrix{
    LL a[110][110];
    LL b[110][110];
    LL c[110][110];
    void clear(){
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
    }
    void print(){
        for(int i=1;i<=n;++i){
            for(int j=1;j<=n;++j){
                printf("%lld ",a[i][j]);
            }printf("\n");
        }printf("\n");
        for(int i=1;i<=n;++i){
            for(int j=1;j<=n;++j){
                printf("%lld ",b[i][j]);
            }printf("\n");
        }printf("\n");
        for(int i=1;i<=n;++i){
            for(int j=1;j<=n;++j){
                printf("%lld ",c[i][j]);
            }printf("\n");
        }printf("\n");
    }
}G,A,B,ans,base;
 
Matrix operator *(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            for(int k=1;k<=n;++k){
                C.a[i][j]=C.a[i][j]+A.c[i][k]*B.a[k][j]+A.a[i][k]*B.c[k][j]+2LL*A.b[i][k]*B.b[k][j];
                C.a[i][j]%=mod;
                C.b[i][j]=C.b[i][j]+A.c[i][k]*B.b[k][j]+A.b[i][k]*B.c[k][j];
                C.b[i][j]%=mod;
                C.c[i][j]=C.c[i][j]+A.c[i][k]*B.c[k][j];
                C.c[i][j]%=mod;
            }
        }
    }return C;
}
Matrix operator +(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j){
            C.c[i][j]=A.c[i][j]+B.c[i][j];
            if(C.c[i][j]>=mod)C.c[i][j]-=mod;
            C.b[i][j]=A.b[i][j]+B.b[i][j];
            if(C.b[i][j]>=mod)C.b[i][j]-=mod;
            C.a[i][j]=A.a[i][j]+B.a[i][j];
            if(C.a[i][j]>=mod)C.a[i][j]-=mod;
        }
    }return C;
}
void Solve(int p){
    for(int i=1;i<=n;++i)ans.c[i][i]=1;
    for(int i=1;i<=n;++i)base.c[i][i]=1;
    A=G;B=G;
    while(p){
        if(p&1){
            ans=ans+A*base;
            base=base*B;
        }
        A=A+A*B;
        B=B*B;p>>=1;
    }
    return;
}
 
int main(){
    scanf("%d%d%d%d",&n,&m,&k,&q);
    for(int i=1;i<=m;++i){
        scanf("%d%d",&u,&v);
        G.a[u][v]++;
        G.b[u][v]++;
        G.c[u][v]++;
    }
    Solve(k);
    while(q--){
        scanf("%d%d",&u,&v);
        printf("%d\n",ans.a[u][v]);
    }
    return 0;
}

BZOJ 4386

由于边权只有1,2,3，所以可以把每个点弄成3个点，这样边权就都是1了，做法跟SCOI 迷路类似

之后我们考虑二分答案，那么我们利用矩阵倍增就可以判断是否有k个

这样时间复杂度O((3*n)^3log^2k)显然会T

首先这道题目我们为了方便统计，可以采用虚拟节点向每个点连边，然后这个虚拟点上带个自环

这样因为有自环的存在我们就不用矩阵倍增，直接快速幂就可以了

不难发现每次二分我们都做了一些重复的工作，我们可以考虑利用倍增

预处理出G^(2^k)，然后从大到小尝试添加看看是否方案数>=k

这样时间复杂度少了一个log

注意到矩阵乘法的过程中可能会爆掉long long

但是我们只需要比较跟K的大小就可以了，爆掉long long显然比K大，所以用-1表示这种情况即可

忘记写成1LL<<L结果T的窝不知所措

注意到答案上界是3*K,极限情况是两个点之间相互有长度为3的边

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cstdlib>
#include<algorithm>
using namespace std;
 
typedef long long LL;
int n,m,u,v,w,N,L;
LL K,ans;
int idx[42][3];
int deg[122];
struct Matrix{
    LL a[122][122];
    void clear(){memset(a,0,sizeof(a));}
}G,C,B,A[72];
void read(int &num){
    num=0;char ch=getchar();
    while(ch<'!')ch=getchar();
    while(ch>='0'&&ch<='9')num=num*10+ch-'0',ch=getchar();
}
Matrix operator *(const Matrix &A,const Matrix &B){
    Matrix C;C.clear();
    for(int i=0;i<=N;++i){
        for(int j=0;j<=N;++j){
            for(int k=0;k<=N;++k){
                if(A.a[i][k]==-1||B.a[k][j]==-1){C.a[i][j]=-1;break;}
                if(A.a[i][k]==0||B.a[k][j]==0)continue;
                if(A.a[i][k]>K/B.a[k][j]){C.a[i][j]=-1;break;}
                C.a[i][j]+=A.a[i][k]*B.a[k][j];
                if(C.a[i][j]>K){C.a[i][j]=-1;break;} 
            }
        }
    }return C;
}
bool judge(){
    LL tot=0;
    for(int i=0;i<=N;++i){
        if(!deg[i])continue;
        if(B.a[0][i]==-1)return false;
        if(B.a[0][i]>K/deg[i])return false;
        tot+=B.a[0][i]*deg[i];
        if(tot>=K)return false;
    }return true;
}
int main(){
    read(n);read(m);scanf("%lld",&K);
    for(int i=1;i<=n;++i){
        for(int j=0;j<3;++j)idx[i][j]=++N;
    }
    for(int i=1;i<=n;++i){
        for(int j=1;j<3;++j){
            u=idx[i][j-1];v=idx[i][j];
            G.a[u][v]++;
        }G.a[0][idx[i][0]]++;
    }G.a[0][0]++;
    for(int i=1;i<=m;++i){
        read(u);read(v);read(w);--w;
        G.a[idx[u][w]][idx[v][0]]++;
        deg[idx[u][w]]++;
    }
    for(L=0;(1LL<<L)<=K*3;L++);
    A[0]=G;ans=1;
    for(int i=1;i<L;++i)A[i]=A[i-1]*A[i-1];
    for(int i=0;i<=N;++i)C.a[i][i]=1;
    for(int i=L-1;i>=0;--i){
        B=C*A[i];
        if(judge()){
            C=B;
            ans+=(1LL<<i);
        }
    }
    if(ans>K*3)printf("-1\n");
    else printf("%lld\n",ans);
    return 0;
}

 

倍增是一种思想，利用的是任意自然数都可以被写成logn位二进制

如果每一位对于答案的贡献是可以独立计算的，那么我们倍增预处理每一位的情况之后合并就可以了

通常也可以用于对二分的转化，求第k大之类的方式

常见的倍增有快速幂，LCA，RMQ，矩阵倍增等等

时间复杂度是log的

转载于:https://www.cnblogs.com/joyouth/p/5539655.html

weixin_30894583
关注
【学习笔记】数论/递推/矩阵/倍增：斐波那契数列
LeeCongWei的博客
08-19 443
到现在，斐波那契数列对于OIer们可谓无人不知无人不晓了 可是，对于大多数初初学者来说，他们只知道一个简单的递推式 而对于一些初学者来说（包括我在内），也只懂得一个矩阵快速幂去优化 事实上，还有一个 O(1)O(1)O(1) 时间复杂度的做法：黄金比例（虽然我看不懂证明过程） 那么我们就来讲讲斐波那契数列吧 斐波那契数列 举个例子，一个很普通的递推：这里有 nnn 层楼梯，每次你可以向上爬1层或2层，你现在在第1层楼梯，问你爬到第 nnn 层楼梯有多少方案。 很显然，递推式就是 Fn=Fn−1+Fn−2F_
矩阵入门总结
yjCola
04-28 1647
利用矩阵乘法可以将一个“向量”转换成令一个“向量”
矩阵倍增
haojunliang_hao的博客
06-04 392
https://blog.csdn.net/u010660276/article/details/35595479
矩阵的运算 --- 倍增法(UVA11149 - Power of Matrix)
Enstein_Jun
03-08 2650
昨天我们介绍了矩阵的快速幂(点我)，相信大家对于矩阵快速幂都有一定的了解。大家也就知道快速幂对于幂运算的迅速，但是当出现了这样的问题：         我们就会发现即便矩阵快速幂再快，我们计算和我们都是O(n)的算法。那么在这个问题上，我们研究问题的重心就从矩阵的幂，转化为了矩阵幂的和。光看这个好像也想不出什么，那么我们换一个角度来思考这个问题。我们现在是要让计算变得更快，对吧？那么怎么样才
道路 - 矩阵乘法 - 倍增
Mys_C_K的博客
05-02 770
题目大意：给定一张图GGG，求∑i=1kiTGi,T,∣G∣≤100,k≤109\sum_{i=1}^ki^TG^i,T,|G|\le100,k\le10^9∑i=1k​iTGi,T,∣G∣≤100,k≤109 题解： 一些显然的做法是把那个幂次拆成斯特林数然后就是要求从路径上再选出若干条不同的边的方案数，这个就可以直接拿来倍增做到O(n^5lgk)了。 考虑直接对这个倍增： ST(k)=∑i=1...
矩阵倍增法uva11149
龙崎的专栏
06-28 717
思路： a[1] + a[2] + a[3] + ... a[n] = (1+a[n/2])(a[1]+...+a[n/2])
uva 11149（矩阵倍增）
勿忘初衷
03-04 1523
Problem B : Power of Matrix Time limit: 10 seconds Consider an n-by-n matrix A. We define Ak = A * A * ... * A (k times). Here, * denotes the usual matrix multiplication. Yo
大学高等代数矩阵知识总结
05-08
### 大学高等代数矩阵知识总结 #### 第四章 矩阵知识点考点精要 ##### 一、矩阵及其运算 **1. 矩阵的概念** - **定义**： - 由 \(s \times n\) 个数 \(a_{ij}\) 排成的数表 \(\begin{pmatrix} a_{11} & \cdots ...
银行客户经理培训学习总结.docx
10-30
以下是对培训内容的详细总结： 首先，培训强调了以积极阳光的心态面对工作的重要性。作为客户经理，面对各种挑战和压力时，保持良好的心态至关重要。积极的工作态度能够帮助我们提升服务水平，使我们在面对困难时更...
计算机体系结构的一些总结
tugouxp的专栏
02-05 1233
广义上来说，按照不同层次的授权等级，可把芯片IP分类为指令集、IP核、芯片架构等。如果说指令集是一本“字典”，那么IP核提供了“段落”的写作方式，芯片架构则可被视作是“整篇文章的提纲”。芯片IP企业作为芯片设计企业的上游供应商，通常以授权的方式，向后者收取专利费用。而芯片设计企业通过购买不同层级的IP授权，可以设计出不同自研程度的芯片产品。
Power of Matrix UVA - 11149(矩阵倍增)
wood
08-18 282
题目链接:点我题意:给你一个矩阵 A, 让你求 A + A2A^{2} + A3A^{3} + A4A^{4} + A5A^{5} + …. AnA^{n},思路:矩阵倍增,那么怎么倍增呢, 令矩阵 S = A + A2A^{2} + A3A^{3} + A4A^{4} + A5A^{5} + … AnA^{n} = A + A2A^{2} + A3A^{3} + A4A^{4} + A5A^{
kuangbin专题十九 矩阵倍增法模板题
Start_to_crazy的博客
01-17 346
题意： A+A^2+A^3+……+A^k，A为矩阵，首先输入A的阶数n和次数k，再输入A，要求将结果输出。 题解： 矩阵倍增法，这道题我是看别人的讲解的，博客如下： http://blog.csdn.net/luomingjun12315/article/details/50824552 http://blog.csdn.net/a601025382s/article/de
C 语言 ：数组元素扩大n倍
graceful_tomorrow的博客
11-17 2635
#include &lt;stdio.h&gt; #define N 10 void Mularray1(int a[],int b); void Mularray2(int *aPtr,int b); void main(){ int a[N] = {1,2,3,4,5,6,7,8,9,10}; int i; printf("原来数组的元素为：\n"); for...
数组元素翻倍C++
xiaofeixia002X的博客
05-08 237
编写一个 C++ 程序，实现一个功能，即。程序应定义一个函数，该函数接收一个整数数组的指针和数组的大小，然后将数组中的每个元素都翻倍。
原创：矩阵论学习心得
weixin_30951231的博客
06-07 1560
矩阵论是对线性代数的延伸，很有必要深入研究。研究矩阵论可以加深对PCA，SVD,矩阵分解的理解，尤其是第一章入门的线性空间的理解，在知识图谱向量化，self_attention等论文中会涉及大量的矩阵论的知识。本文对此做一个总结，分为以下结构: 第一部分：矩阵的线性空间，矩阵的意义; 第二部分：矩阵的范数理解，self_attention以及transD论文核心技术解读; 第三部分：矩阵的分...
浅谈矩阵变换——Matrix
热门推荐
走向远方
09-05 4万+
矩阵变换在图形学上经常用到。基本的常用矩阵变换操作包括平移、缩放、旋转、斜切。 每种变换都对应一个变换矩阵，通过矩阵乘法，可以把多个变换矩阵相乘得到复合变换矩阵。 矩阵乘法不支持交换律，因此不同的变换顺序得到的变换矩阵也是不相同的。 事实上，图像处理时，矩阵的运算是从右边往左边方向进行运算的。这就形成了越在右边(右乘)的矩阵，越先运算(先乘)，反之亦然
Windows系统远程桌面设置（附win11家庭版开启组策略功能及远程桌面）
最新发布
11-10
Windows系统远程桌面设置（附win11家庭版开启组策略功能及远程桌面）
一个兼容vue 2.x-3.x 的vue-seamless-scroll区域滚动插件
11-10
一个兼容vue 2.x-3.x 的vue-seamless-scroll区域滚动插件
名人堂网页源代码压缩包
11-10
我的目标是打造一个平台，让人们能够轻松地探索和学习那些对世界产生深远影响的杰出人物。
机器学习中的矩阵求导简明教程
"这篇教程旨在帮助读者快速掌握矩阵和向量在机器学习中的求导法则，特别是针对复合函数的链式法则。它不是一本严格的数学教材，而是为那些需要将这些概念应用于实践的读者设计的。教程假设读者已经熟悉一元函数的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值