网络流—最大流算法模板总结

最新推荐文章于 2023-02-04 00:34:40 发布
最新推荐文章于 2023-02-04 00:34:40 发布
阅读量388 收藏 2
点赞数
分类专栏： 网络流—最大流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44293044/article/details/98875286
版权

Dinic算法（研究总结，网络流）

网络流基本概念

什么是网络流
在一个有向图上选择一个源点，一个汇点，每一条边上都有一个流量上限（以下称为容量），即经过这条边的流量不能超过这个上界，同时，除源点和汇点外，所有点的入流和出流都相等，而源点只有流出的流，汇点只有汇入的流。这样的图叫做网络流。
所谓网络或容量网络指的是一个连通的赋权有向图 D= （V、E、C） ， 其中V 是该图的顶点集，E是有向边(即弧)集，C是弧上的容量。此外顶点集中包括一个起点和一个终点。网络上的流就是由起点流向终点的可行流，这是定义在网络上的非负函数，它一方面受到容量的限制，另一方面除去起点和终点以外，在所有中途点要求保持流入量和流出量是平衡的。（引自百度百科）

定义

我们定义：
源点：只有流出去的点
汇点：只有流进来的点
流量：一条边上流过的流量
容量：一条边上可供流过的最大流量
残量：一条边上的容量-流量

几个基本性质

基本性质一：
对于任何一条流，总有流量<=容量

基本性质二
对于任何一个不是源点或汇点的点u，总有
∑p∈Ek[p][u]==∑q∈Ek[u][q]（其中k[i][j]表示i到j的流量）
∑p∈Ek[p][u]==∑q∈Ek[u][q]（其中k[i][j]表示i到j的流量）

这个也很显然，即一个点（除源点和汇点）的入流和出流相等

基本性质三
对于任何一条有向边(u,v)，总有
k[u][v]==−k[v][u]
k[u][v]==−k[v][u]

这个看起来并不是很好理解，它的意思就是一条边的反边上的流是这条边的流的相反数，可以这么想，就是如果有k[u][v]的流从u流向v，也就相当于有-k[v][u]的流从v流向u。这条性质非常重要。

网络流最大流

网络流的最大流算法就是指的一个流量的方案使得网络中流量最大。

网络流最大流的求解

网络流的所有算法都是基于一种增广路的思想，下面首先简要的说一下增广路思想，其基本步骤如下：

1.找到一条从源点到汇点的路径，使得路径上任意一条边的残量>0（注意是小于而不是小于等于，这意味着这条边还可以分配流量），这条路径便称为增广路
2.找到这条路径上最小的F[u][v]（我们设F[u][v]表示u->v这条边上的残量即剩余流量），下面记为flow
3.将这条路径上的每一条有向边u->v的残量减去flow，同时对于起反向边v->u的残量加上flow（为什么呢？我们下面再讲）
4.重复上述过程，直到找不出增广路，此时我们就找到了最大流

这个算法是基于增广路定理(Augmenting Path Theorem): 网络达到最大流当且仅当残留网络中没有增广路（由于笔者知识水平不高，暂且不会证明）
在这里插入图片描述
为什么要连反向边

我们知道，当我们在寻找增广路的时候，在前面找出的不一定是最优解，如果我们在减去残量网络中正向边的同时将相对应的反向边加上对应的值，我们就相当于可以反悔从这条边流过。
比如说我们现在选择从u流向v一些流量，但是我们后面发现，如果有另外的流量从p流向v，而原来u流过来的流量可以从u->q流走，这样就可以增加总流量，其效果就相当于p->v->u->q，用图表示就是：
在这里插入图片描述
图中的蓝色边就是我们首次增广时选择的流量方案，而实际上如果是橘色边的话情况会更优，那么我们可以在v->u之间连一条边容量为u->v减去的容量，那我们在增广p->v->u->q的时候就相当于走了v->u这条"边"，而u->v的流量就与v->u的流量相抵消，就成了中间那幅图的样子了。
如果是v->u时的流量不能完全抵消u->v的，那就说明u还可以流一部分流量到v，再从v流出，这样也是允许的。

一个小技巧
虽然说我们已经想明白了为什么要加反向边，但反向边如何具体实现呢？笔者在学习网络流的时候在这里困扰了好久，现在简要的总结在这里。
首先讲一下邻接矩阵的做法，对于G[u][v]，如果我们要对其反向边进行处理，直接修改G[v][u]即可。
但有时会出现u->v和v->u同时本来就有边的情况，一种方法是加入一个新点p，使u->v，而v->u变成v->p,p->u。
另一种方法就是使用邻接表，我们把边从0开始编号，每加入一条原图中的边u->v时，加入边v->u流量设为0，那么这时对于编号为i的边u->v，我们就可以知道i^1就是其反向边v->u。
朴素算法的低效之处
虽然说我们已经知道了增广路的实现，但是单纯地这样选择可能会陷入不好的境地，比如说这个经典的例子：
在这里插入图片描述
我们一眼可以看出最大流是999(s->v->t)+999(s->u->t)，但如果程序采取了不恰当的增广策略：s->v->u->t
在这里插入图片描述
我们发现中间会加一条u->v的边
在这里插入图片描述
而下一次增广时：
在这里插入图片描述
若选择了s->u->v->t
在这里插入图片描述
然后就变成
在这里插入图片描述
这是个非常低效的过程，并且当图中的999变成更大的数时，这个劣势还会更加明显。
怎么办呢？
这时我们引入Dinic算法
Dinic算法

为了解决我们上面遇到的低效方法，Dinic算法引入了一个叫做分层图的概念。具体就是对于每一个点，我们根据从源点开始的bfs序列，为每一个点分配一个深度，然后我们进行若干遍dfs寻找增广路，每一次由u推出v必须保证v的深度必须是u的深度+1。下面给出代码
一些变量的定义

int s,t;//源点和汇点
int cnt;//边的数量，从0开始编号。
int Head[maxN];//每一个点最后一条边的编号
int Next[maxM];//指向对应点的前一条边
int V[maxM];//每一条边指向的点
int W[maxM];//每一条边的残量
int Depth[maxN];//分层图中标记深度

Dinic主过程：

int Dinic()
{
    int Ans=0;//记录最大流量
    while (bfs())
    {
        while (int d=dfs(s,inf))
            Ans+=d;
    }
    return Ans;
}

bfs分层图过程

bool bfs()
{
    queue<int> Q;//定义一个bfs寻找分层图时的队列
    while (!Q.empty())
        Q.pop();
    memset(Depth,0,sizeof(Depth));
    Depth[s]=1;//源点深度为1
    Q.push(s);
    do
    {
        int u=Q.front();
        Q.pop();
        for (int i=Head[u];i!=-1;i=Next[i])
            if ((W[i]>0)&&(Depth[V[i]]==0))//若该残量不为0，且V[i]还未分配深度，则给其分配深度并放入队列
            {
                Depth[V[i]]=Depth[u]+1;
                Q.push(V[i]);
            }
    }
    while (!Q.empty());
    if (Depth[t]==0)//当汇点的深度不存在时，说明不存在分层图，同时也说明不存在增广路
        return 0;
    return 1;
}

dfs寻找增广路过程

int dfs(int u,int dist)//u是当前节点，dist是当前流量
{
    if (u==t)//当已经到达汇点，直接返回
        return dist;
    for (int i=Head[u];i!=-1;i=Next[i])
    {
        if ((Depth[V[i]]==Depth[u]+1)&&(W[i]!=0))//注意这里要满足分层图和残量不为0两个条件
        {
            int di=dfs(V[i],min(dist,W[i]));//向下增广
            if (di>0)//若增广成功
            {
                W[i]-=di;//正向边减
                W[i^1]+=di;反向边加
                return di;//向上传递
            }
        }
    }
    return 0;//否则说明没有增广路，返回0
}

把上面的内容都封装到类中：


class Graph
{
private:
    int s,t;
    int cnt;
    int Head[maxN];
    int Next[maxM];
    int V[maxM];
    int W[maxM];
    int Depth[maxN];
public:
    int n;
    void init(int nn,int ss,int tt)//初始化
        {
            n=nn;
            s=ss;
            t=tt;
            cnt=-1;
            memset(Head,-1,sizeof(Head));
            memset(Next,-1,sizeof(Next));
            return;
        }
    void _Add(int u,int v,int w)
        {
            cnt++;
            Next[cnt]=Head[u];
            V[cnt]=v;
            W[cnt]=w;
            Head[u]=cnt;
        }
    void Add_Edge(int u,int v,int w)//加边，同时加正向和反向的
        {
            _Add(u,v,w);
            _Add(v,u,0);
        }
    int dfs(int u,int dist)
        {
            //cout<<"Dfs:"<<u<<' '<<dist<<endl;
            if (u==t)
                return dist;
            for (int i=Head[u];i!=-1;i=Next[i])
            {
                if ((Depth[V[i]]==Depth[u]+1)&&(W[i]!=0))
                {
                    int di=dfs(V[i],min(dist,W[i]));
                    if (di>0)
                    {
                        W[i]-=di;
                        W[i^1]+=di;
                        return di;
                    }
                }
            }
            return 0;
        }
    int bfs()
        {
            //cout<<"Bfs.begin:"<<endl;
            queue<int> Q;
            while (!Q.empty())
                Q.pop();
            memset(Depth,0,sizeof(Depth));
            Depth[s]=1;
            Q.push(s);
            do
            {
                int u=Q.front();
                //cout<<u<<endl;
                Q.pop();
                for (int i=Head[u];i!=-1;i=Next[i])
                {
                    if ((W[i]>0)&&(Depth[V[i]]==0))
                    {
                        Depth[V[i]]=Depth[u]+1;
                        Q.push(V[i]);
                    }
                }
            }
            while (!Q.empty());
            //cout<<"Bfs.end"<<endl;
            if (Depth[t]>0)
                return 1;
            return 0;
        }
    int Dinic()
        {
            int Ans=0;
            while (bfs())
            {
                while (int d=dfs(s,inf))
                    Ans+=d;
            }
            return Ans;
        }
};

Dinic算法的优化

Dinic算法还有优化，这个优化被称为当前弧优化，即每一次dfs增广时不从第一条边开始，而是用一个数组cur记录点u之前循环到了哪一条边，以此来加速
总代码如下，修改的地方已在代码中标出：

class Graph
{
private:
    int cnt;
    int Head[maxN];
    int Next[maxM];
    int W[maxM];
    int V[maxM];
    int Depth[maxN];
    int cur[maxN];//cur就是记录当前点u循环到了哪一条边
public:
    int s,t;
    void init()
        {
            cnt=-1;
            memset(Head,-1,sizeof(Head));
            memset(Next,-1,sizeof(Next));
        }
    void _Add(int u,int v,int w)
        {
            cnt++;
            Next[cnt]=Head[u];
            Head[u]=cnt;
            V[cnt]=v;
            W[cnt]=w;
        }
    void Add_Edge(int u,int v,int w)
        {
            _Add(u,v,w);
            _Add(v,u,0);
        }
    int dfs(int u,int flow)
        {
            if (u==t)
                return flow;
            for (int& i=cur[u];i!=-1;i=Next[i])//注意这里的&符号，这样i增加的同时也能改变cur[u]的值，达到记录当前弧的目的
            {
                if ((Depth[V[i]]==Depth[u]+1)&&(W[i]!=0))
                {
                    int di=dfs(V[i],min(flow,W[i]));
                    if (di>0)
                    {
                        W[i]-=di;
                        W[i^1]+=di;
                        return di;
                    }
                }
            }
            return 0;
        }
    int bfs()
        {
            queue<int> Q;
            while (!Q.empty())
                Q.pop();
            memset(Depth,0,sizeof(Depth));
            Depth[s]=1;
            Q.push(s);
            do
            {
                int u=Q.front();
                Q.pop();
                for (int i=Head[u];i!=-1;i=Next[i])
                    if ((Depth[V[i]]==0)&&(W[i]>0))
                    {
                        Depth[V[i]]=Depth[u]+1;
                        Q.push(V[i]);
                    }
            }
            while (!Q.empty());
            if (Depth[t]>0)
                return 1;
            return 0;
        }
    int Dinic()
        {
            int Ans=0;
            while (bfs())
            {
                for (int i=1;i<=n;i++)//每一次建立完分层图后都要把cur置为每一个点的第一条边 感谢@青衫白叙指出这里之前的一个疏漏
                    cur[i]=Head[i];
                while (int d=dfs(s,inf))
                {
                    Ans+=d;
                }
            }
            return Ans;
        }
};

EK算法模板

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int INF=0x7ffffff;

queue <int> q;
int n,m,x,y,s,t,g[201][201],pre[201],flow[201],maxflow; 
//g邻接矩阵存图，pre增广路径中每个点的前驱，flow源点到这个点的流量 （就是増广路（min））！ 

inline int bfs(int s,int t)
{
    while (!q.empty()) q.pop();//清空！ 
    for (int i=1; i<=n; i++) pre[i]=-1;//清空！！！ 
    pre[s]=0;
    q.push(s);
    flow[s]=INF;
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        if (x==t) break;
        for (int i=1; i<=n; i++)
          //EK一次只找一个增广路 ,这句话非常的重要啊！！！！！important！ very important！ very very important！！！
          //不认真看这句话，不要怪下面自己看不懂！ 
          if (g[x][i]>0 && pre[i]==-1)//如果当时x到i点有容量，并且i点还没有找到前驱 
          {
            pre[i]=x;
            flow[i]=min(flow[x],g[x][i]);//是不是觉得有一点像SPFA ？？？ 找最小的増广路 
            q.push(i);
          }
    }
    if (pre[t]==-1) return -1;//死啦！ 
    else return flow[t];
}

//increase为增广的流量 
void EK(int s,int t)
{
    int increase=0;
    while ((increase=bfs(s,t))!=-1)//这里的括号加错了！Tle 
    {//迭代 
        int k=t;//k等于终点 
        while (k!=s)//当k不为起点时 
        {
            int last=pre[k];//从后往前找路径
            g[last][k]-=increase;//正着走残量网络要减去增广量 
            g[k][last]+=increase;//反之，反着走要加上增广量 
            k=last;
        }
        maxflow+=increase;//增加増广路 
    }
}

int main()
{
    scanf("%d%d",&m,&n);//m是挖了几条沟，n是有几条汇点 ，最后一个点n也是小溪的编号 
    for (int i=1; i<=m; i++)
    {
        int z;
        scanf("%d%d%d",&x,&y,&z);
        g[x][y]+=z;//此处不可直接输入，要+= ，为什么？？？？？？？？？？？？？？？important 
    }
    EK(1,n);
    printf("%d",maxflow);
    return 0;
}

下面大家就会发现一个问题，用邻接矩阵存储，是不是也太费空间了，要是题目让你跑一个有10000个点的网络流岂不凉凉！！！

下面就要献上我们改装过的EK算法！（说白了就是Dinic）

#include<bits/stdc++.h>
using namespace std;
struct listx{
    int to,next=0,f;
}edge[200005];
int cnt=0,n,m,s,t;
int head[10005];
int depth[10005];
void update(int num,int flow)
{
    edge[num].f-=flow;
    edge[num+1].f+=flow;
}
void addedge(int u,int v,int w)
{
    cnt++;
    edge[cnt].next=head[u];
    edge[cnt].to=v;
    edge[cnt].f=w;
    head[u]=cnt;
}
bool bfs()
{
    memset(depth,0,sizeof(depth));
    queue<int>que;
    while(!que.empty())
          {
             que.pop();
          }
    que.push(s);
    depth[s]=1;
    while(!que.empty())
          {
              int cur=que.front();
              que.pop();
              if(cur==t)
                 break;
              for(int i=head[cur];i!=0;i=edge[i].next)
                  {
                    listx temp=edge[i];
                    if(depth[temp.to]==0&&temp.f>0)
                       {
                           depth[temp.to]=depth[cur]+1;
                           que.push(temp.to);
                       }
                  }
          } 
    if(depth[t]==0)
       return false;
    return true;          
}
int dfs(int u,int flow)
{
    if(u==t)
       return flow;
    for(int i=head[u];i!=0;i=edge[i].next)
        {
            listx temp=edge[i];
            if(depth[u]+1==depth[temp.to]&&temp.f>0)
               {
                  flow=flow<temp.f?flow:temp.f;
                  int newx=dfs(temp.to,flow);
                  if(newx>0)
                     {
                        update(i,newx);
                        return newx;
                     }
               }
        }
     return 0;   
}
int main()
{
    int ans=0;
    scanf("%d%d%d%d",&n,&m,&s,&t);
    for(int i=1;i<=m;i++)
        {
            int a1,b1,c1;
            scanf("%d%d%d",&a1,&b1,&c1);  
            addedge(a1,b1,c1);
            addedge(b1,a1,0);
        }
    while(bfs())
          {
             int k;
             while(k=dfs(s,10000000))
                   {
                      ans+=k;
                   }
          }
    printf("%d",ans);
    return 0;
}
发型睡姿决定
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网络流最大流
m0_51339444的博客
04-07 1031
网络流最大流
最大流 --- Edmond Karp算法
梅子酒的博客
07-30 1277
本文转载于最大流 — Edmond Karp算法因原文部分图片及代码显示问题，阅读不方便，故转载。 Edmond Karp算法的大概思想： 反复寻找源点s到汇点t之间的增广路径，若有，找出增广路径上每一段[容量-流量]的最小值delta，若无，则结束。 在寻找增广路径时，可以用BFS来找，并且更新残留网络的值(涉及到反向边)。 而找到delta后，则使最大流值加上delta，更新为当前的最大流值。 (粗体表明需要掌握的概念) 关于反向边： 以下摘至HDOJ的课件和网上的： 首先来看一下基本的网络流最大流模型
网络流之最大流
weixin_52551400的博客
03-20 258
网络流的基本概念 在一张有向图中 G = (V, E) 中有一个源点 S 和一个汇点 T。 源点 S 有无限多的水流可以向外流出，汇点 T 可以接受无限多的水流。 其中对于每一条有向边有一个边权代表这条有向边最大可以流过的流量(用 c(u, v) 来表示)。 最大流指的是最大可行流 残留网络 然后每一个流都会有一个残留网络 残留网络指的是在原网络中指定了可行流之后对应的一个网络流，原网络的一个可行流对应一个残留网络。 该红色箭头的所指路径即为残留网络 其中的 其中残留网络的可行流 f’ 同样需满足 流量守
网络流基础-最大流最小割定理
weixin_34025051的博客
08-09 624
最大流最小割定理，指网络流的最大流等于其最小割。 最大流指符合三个性质的前提下，从S到T能流过的最大流量。 最小割指符合割的定义，最小的割容量。 求最大流： 不断寻找增广路，计算能增加的最小流量，然后增加。 找到一条增光路，最多能流过2，则： 找到第二条路径： 最后还剩a-c-e一条，则可计算出最大流量为4。 但遇到以下情况，且第一条路径为a-b-c-d时，就不行...
【最大流】Ford-Fulkerson算法——算法设计与分析
友人帐_的博客
02-04 3223
介绍了最大流问题及其相关概念，通过直观策略引入并介绍了Ford-Fulkerson算法，给出实例讲解。
最小费用最大流模板
11-26
总结来说，这个模板实现了一个基于SPFA算法的最小费用最大流问题求解器，适用于处理具有费用和容量限制的网络流问题。在实际应用中，这样的算法可以应用于物流、电力分配、网络带宽分配等需要考虑成本和最大能力的...
ACM算法模板和pku代码
11-09
本科参加ACM竞赛的过程中积累下来的一部分算法模板，和自己在PKU上面做的一部分题目。 模板目录结构： 目录: 动态规划 O(n^2)的最长上升子序列 nlogn最长上升子序列 高精度 计算几何 Graham扫描法 两线段交点 凸...
java背包算法包含文档
最新发布
09-14
背包问题的解决方法可以扩展到其他领域，如任务调度、资源分配、网络流优化等。 10. **范文/模板/素材**： 提供的压缩包文件可能包含了各种Java实现背包算法的示例代码、解题思路和模板，对于学习和理解算法非常...
ACM常用模板总结ACM常用模板总结
07-18
图论_网络流\ 上下界最大流(邻接阵形式) 上下界最小流(邻接阵形式) 上下界最大流(邻接表形式) 上下界最小流(邻接表形式) 最大流(邻接阵形式) 最大流(邻接表形式) 最大流(邻接表形式,邻接阵接口) 最大流...
ACM算法总结大全——超有用!.pdf
03-11
6. **最大流的增广路算法**：KM算法用于求解网络中的最大流量，如POJ1459、POJ3436。 **数据结构** 1. **字符串**：如POJ1035、POJ3080和POJ1936中的处理。 2. **排序**：快速排序、归并排序、堆排序，其中归并...
网络流——最大流算法（C语言实现）
brench11的博客
03-11 3064
最大流算法 最大流算法是图论的一个重要算法，可以应用在管道运输等方面。 现在给出一个有向图，点1为出发点，点6为收点，计算由点1到点6的最大流
【网络流】最大流：最大流判定，拆点，建图实战
ZYzyZzzz的博客
08-11 692
最大流判定 秘密挤奶机 原题链接 给出一张包含NNN个点，PPP条边的无向图，1→N1\rightarrow N1→N走TTT次，每条边最多走111次。 问：TTT条路径中最大边权的最小值。 用dinic+dinic+dinic+二分。 判定问题：在无向图中，删除大于midmidmid的边，查找边权≤mid\leq mid≤mid的边，1→N1\rightarrow N1→N是否存在TTT条没有公共边的路径。 建图：将无向图变为有向图： S=1,T=nS=1,T=nS=1,T=n，最大可行流流量===路
网络流之最大流算法总结（FF， EK， Dinic）
张宜强的博客
11-26 6368
目录 FF算法：最基础的最大流算法 EK算法：每次BFS寻找増广路 Dinic算法：EK算法的优化 Dinic+链式前向星 这里以POJ1273这道题为例，题目链接：http://poj.org/problem?id=1273 FF算法：最基础的最大流算法 通过DFS増广，直到不能増广为止。 记最大流的流量为F，FF算法最多进行F次DFS，所以其复杂度为O(F|E|)，每一次DFS...
最大网络流算法
qq_42712351的博客
07-20 545
参考题目HDU 3549 这是一个裸题，给定流网络，直接求最大网络流。 什么是网络流？   设流网络G=(V,E)G=(V,E)G=(V,E)是一个有向图，图中每条边(u,v)∈E(u,v)\in E(u,v)∈E有一个非负容量值c(u,v)≥0c(u,v)\geq0c(u,v)≥0。在所有结点中存在两个特殊结点：源节点sss和汇结点ttt；源节点只出不进，汇结点只进不出。为方便起见，假设每个结点...
网络流~最大流算法模板题
feng_zhiyu的博客
02-02 856
Ford-Fulkerson算法 记F为最大流的流量。 通过深度优先搜索寻找增广路，并沿着它增广。 时间复杂度 O(FE) E为边的条数 模板题：【hdu 1532】 （Ford-Fulkerson算法和Dinic算法） Ford-Fulkerson算法 模板代码： #include &lt;cstdio&gt; #include &lt;iostream&gt; #includ...
最大流算法模板
qq_47188574的博客
01-27 80
Dinic ISAP HLLP
网络最大流模板(Edmonds-Karp算法)
jizhihong的博客
04-29 419
测试模板能不能过的——————题目链接 邻接矩阵存图 #include <iostream> #include <cstdio> #include <cstring> #include <queue> const int inf = 0x3f3f3f3f; const int maxn = 10050; using namespace std; i...
最大流模板--dinic算法
Stagflation的博客
07-07 231
sorry我上次传的是费用流，慢的一批，这次更正下。 #include <bits/stdc++.h> using namespace std; #define limit (100000 + 5)//防止溢出 #define INF 0x3f3f3f3f #define inf 0x3f3f3f3f3f #define lowbit(i) i&(-i)//一步两步 #define EPS 1e-6 #define FASTIO ios::sync_with_stdio(false);

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值