字符串匹配的三个算法（KMP+字典树+AC自动机）

最新推荐文章于 2024-06-27 07:30:52 发布
最新推荐文章于 2024-06-27 07:30:52 发布
阅读量1.2w 收藏 63
点赞数 16
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30346729/article/details/78835040
版权

字符串匹配的意思是给一个字符串集合，和另一个字符串集合，看这两个集合交集是多少。

若是都只有一个字符串，那么就看其中一个是否包含另外一个；

若是父串集合（比较长的，被当做模板）的有多个，子串（拿去匹配的）只有一个，就是问这个子串是否存在于父串之中；

若是子串父串集合都有多个，那么就是问交集了。


1.KMP算法

KMP算法是用来处理一对一的匹配的。

朴素的匹配算法，或者说暴力匹配法，就是将两个字符串从头比到尾，若是有一个不同，那么从下一位再开始比。这样太慢了。所以KMP算法的思想是，对匹配串本身先做一个处理，得到一个next数组。这个数组是做什么用的呢？next [j] = k，代表j之前的字符串中有最大长度为k 的相同前缀后缀。记录这个有什么用呢？对于ABCDABC这个串，如果我们匹配ABCDABTBCDABC这个长串，当匹配到第7个字符T的时候就不匹配了,我们就不用直接移到B开始再比一次，而是直接移到第5位来比较，岂不美哉？所以求出了next数组，KMP就完成了一大半。next数组也可以说是开始比较的位数。

计算next数组的方法是对于长度为n的匹配串，从0到n-1位依次求出前缀后缀最大匹配长度。

比如ABCDABD这个串:


（图片来源https://www.cnblogs.com/zhangtianq/p/5839909.html）

如何去求next数组呢？k是匹配下标。这里没有从最后一位开始和第一位开始分别比较前缀后缀，而是利用了next[i-1]的结果。

void getnext()//获取next数组
{
    int i,n,k;
    n=strlen(ptr);
    memset(next,0,sizeof(next));
    k=0;
    for(i=1;i<n;i++)
    {
        while(k>0 && ptr[k]!=ptr[i])
            k=next[k];
        if(ptr[k]==ptr[i]) k++;
        next[i+1]=k;
	//next表示的是匹配长度
    }
}
这里我是按照《算法导论》的代码来写的。算法导论算法循环是从1到n而不是从0到n-1，所以在下面匹配的时候需要j=next[j+1]。 

int kmp(char *a,char *b)//匹配ab两串，a为父串
{
    int i=0,j=0;
    int len1=strlen(a);
    int len2=strlen(b);
    getnext();
    while(i<len1&&j<len2)
    {
        if(j==0||a[i]==b[j])
        {   i++;j++;       }
        else j=next[j+1];//到前一个匹配点
    }
    if(j>=len2)
        return i-j;
    else return -1;
}
这里next数组的作用就显现出来了。最后返回的是i-j，也就是说，是从i位置前面的第j位开始的，也就是上面说的， next数组也可以说是开始比较的位数。也就是说，在父串的i位比的时候已经是在比子串的第j位了。

一个完整的代码：

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
const int N=100;
char str[100],ptr[100];//父串str和子串ptr
int next[100];
string ans;
void getnext()//获取next数组
{
    int i,n,k;
    n=strlen(ptr);
    memset(next,0,sizeof(next));
    k=0;
    for(i=1;i<n;i++)
    {
        while(k>0 && ptr[k]!=ptr[i])
            k=next[k];
        if(ptr[k]==ptr[i]) k++;
        next[i+1]=k;
	//next表示的是匹配长度
    }
}
int kmp(char *a,char *b)//匹配ab两串，a为父串
{
    int i=0,j=0;
    int len1=strlen(a);
    int len2=strlen(b);
    getnext();
    while(i<len1&&j<len2)
    {
        if(j==0||a[i]==b[j])
        {   i++;j++;       }
        else j=next[j+1];//到前一个匹配点
    }
    if(j>=len2)
        return i-j;
    else return -1;
}
int main(){
	while( scanf( "%s%s", str, ptr ) )
	{
        int ans = kmp(str,ptr);
        if(ans>=0)
            printf( "%d\n", kmp( str,ptr ));
        else
            printf("Not find\n");
	}
	return 0;
}


2.字典树算法

上面的KMP是一对一匹配的时候常用的算法。而字典树则是一对多的时候匹配常用算法。其含义是，把一系列的模板串放到一个树里面，然后每个节点存的是它自己的字符，从根节点开始往下遍历就可以得到一个个单词了。


(图片来自百度)

我这里写的代码稍微和上面有一点区别，我的节点tnode里面没有存它本身的字符，而是存一个孩子数组。所以当数据量很大的时候还是需要做一些变通的，不可直接套用此代码。若是想以每个节点为一个node，那么要注意根节点是空的。

树的节点tnode，这里的next[i]存的是子节点指针。sum=0表示这个点不是重点。为n>0表示有n个单词以此为终点。

struct tnode{
    int sum;//用来判断是否是终点的
    tnode* next[26];
    tnode(){
        for(int i =0;i<26;i++)
            next[i]=NULL;
        sum=0;
    }
};

插入函数：

这个newnode是手写的构造函数.C++类有些坑，不像java那么...随便。

假设字典树已经有了aer，现在插入abc,首先看a,不为空，那么直接跳到a节点里，看b，为空，那么新建，跳到b里，新建c，跳出。

tnode* newnode(){
    tnode *p = new tnode;
    for(int i =0;i<26;i++)
        p->next[i]=NULL;
    p->sum=0;
    return p;
}
//插入函数
void Insert(char *s)
{
    tnode *p = root;
    for(int i = 0 ; s[i] ; i++)
    {
        int x = s[i] - 'a';
        if(p->next[x]==NULL)
        {
            tnode *nn=newnode();
            for(int j=0;j<26;j++)
                nn->next[j] = NULL;
            nn->sum = 0;
            p->next[x]=nn;
        }
        p = p->next[x];
    }
    p->sum++;//这个单词终止啦
}
字符串比较：就是一个个字符去比呗...时间复杂度O(m)，m是匹配串长度。 

bool Compare(char *ch)
{
    tnode *p = root;
    int len = strlen(ch);
    for(int i = 0; i < len; i++)
    {
        int x = ch[i] - 'a';
        p = p->next[x];
        if(p==NULL)
            return false;
        if(i==len-1 && p->sum>0 ){
            return true;
        }
    }
    return false;
}

给个完整的代码： 

#include<queue>
#include<set>
#include<cstdio>
#include <iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
/*
    trie字典树
*/
struct tnode{
    int sum;//用来判断是否是终点的
    tnode* next[26];
    tnode(){
        for(int i =0;i<26;i++)
            next[i]=NULL;
        sum=0;
    }
};
tnode *root;

tnode* newnode(){
    tnode *p = new tnode;
    for(int i =0;i<26;i++)
        p->next[i]=NULL;
    p->sum=0;
    return p;
}
//插入函数
void Insert(char *s)
{
    tnode *p = root;
    for(int i = 0 ; s[i] ; i++)
    {
        int x = s[i] - 'a';
        if(p->next[x]==NULL)
        {
            tnode *nn=newnode();
            for(int j=0;j<26;j++)
                nn->next[j] = NULL;
            nn->sum = 0;
            p->next[x]=nn;
        }
        p = p->next[x];
    }
    p->sum++;//这个单词终止啦
}
//匹配函数
bool Compare(char *ch)
{
    tnode *p = root;
    int len = strlen(ch);
    for(int i = 0; i < len; i++)
    {
        int x = ch[i] - 'a';
        p = p->next[x];
        if(p==NULL)
            return false;
        if(i==len-1 && p->sum>0 ){
            return true;
        }
    }
    return false;
}
void DELETE(tnode * &top){
    if(top==NULL)
    return;
    for(int i =0;i<26;i++)
        DELETE(top->next[i]);
    delete top;
}
int main()
{
    int n,m;
    cin>>n;
    char s[20];
    root = newnode();
    for(int i =0;i<n;i++){
        scanf("%s",s);
        Insert(s);
    }
    cin>>m;
    for(int i =0;i<m;i++){
        scanf("%s",s);
        if(Compare(s))
            cout<<"YES"<<endl;
        else
            cout<<"NO"<<endl;
    }
    DELETE(root);//看见指针就要想到释放,然而这东西会花时间，所以网上很多人写ACM题就不delete了，我很看不惯这一点。
    return 0;
}

3.AC自动机

字典树是一对多的匹配，那么AC自动机就是多对多的匹配了。意思是：给一个字典，再给一个m长的文本，问这个文本里出现了字典里的哪些字。

这个问题可以用n个单词的n次KMP算法来做(效率为O(n*m*单词平均长度))，也可以用1个字典树去匹配文本串的每个字母位置来做(效率为O(m*每次字典树遍历的平均深度))。上面两种解法效率都不高，如果用AC自动机来解决的话，效率将为线性O(m)时间复杂度。

AC自动机也运用了一点KMP算法的思想。简述为字典树+KMP也未为不可。

首先讲一下acnode的结构：

与字典树相比，就多了个*fail对吧，这个就相当于KMP算法里的next数组。只不过它存的是失配后跳转的位置，而不是跳转之后再向前跳了多少罢了。

struct acnode{
    int sum;
    acnode* next[26];
    acnode* fail;
    acnode(){
        for(int i =0;i<26;i++)
            next[i]=NULL;
        fail= NULL;
        sum=0;
    }
};

插入什么的我就不说了，记得把fail置为空即可。

这里说一下fail指针的获取。fail指针是通过BFS来求的。

看这么一张图


（图片来自百度）

图中数字我们不用管它，绿色代表是终点，虚线就是fail指针了。我们可以看到91 E节点的fail指针是指向76 E 的，也就是说执行到这里如果无法继续匹配就会跳到76 E那个节点继续往后匹配。我们可以看到它们前面都是H，也就是说fail指针指向的是父节点相同的同值节点（根节点视为与任何节点相同）。我们要算的是在一个长文本里面有多少个出现的单词，这个fail指针就是为了快速匹配而诞生的。若文本里出现了HISHERS,我们首先匹配了HIS,有通过fail指针跳到85 S从而匹配SHE，再匹配HERS。fail指针跳到哪里就代表这一点之前的内容已经被匹配了。这样就避免了再从头重复判断的过程。

在函数里，当前节点的fail指针也会去更新此节点的孩子的fail指针，因为父节点相同啊~而且因为它是此节点的fail指针，这两个节点的父节点也相同啊~所以一路相同过来，就保证fail指向的位置前缀是相同的。

void getfail(){
    queue<acnode*> q;
	for(int i = 0 ; i < 26 ; i ++ )
	{
		if(root->next[i]!=NULL){
			root->next[i]->fail = root;
			q.push(root->next[i]);
		}
	}
    while(!q.empty()){
        acnode* tem = q.front();
        q.pop();
        for(int i = 0;i<26;i++){
            if(tem->next[i]!=NULL)
            {
                acnode *p;
                p = tem->fail;
                while(p!=NULL){
                    if(p->next[i]!=NULL){
                        tem->next[i]->fail = p->next[i];
                        break;
                    }
                    p=p->fail;
                }
                if(p==NULL)
                   tem->next[i]->fail = root;
                q.push(tem->next[i]);
            }
        }
    }
}

全部代码如下：

#include<queue>
#include<set>
#include<cstdio>
#include <iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
/*
    ac自动机
*/
struct acnode{
    int sum;
    acnode* next[26];
    acnode* fail;
    acnode(){
        for(int i =0;i<26;i++)
            next[i]=NULL;
        fail= NULL;
        sum=0;
    }
};
acnode *root;
int cnt;
acnode* newnode(){
    acnode *p = new acnode;
    for(int i =0;i<26;i++)
        p->next[i]=NULL;
    p->fail = NULL;
    p->sum=0;
    return p;
}
//插入函数
void Insert(char *s)
{
    acnode *p = root;
    for(int i = 0; s[i]; i++)
    {
        int x = s[i] - 'a';
        if(p->next[x]==NULL)
        {
            acnode *nn=newnode();
            for(int j=0;j<26;j++)
                nn->next[j] = NULL;
            nn->sum = 0;
            nn->fail = NULL;
            p->next[x]=nn;
        }
        p = p->next[x];
    }
    p->sum++;
}
//获取fail指针，在插入结束之后使用
void getfail(){
    queue<acnode*> q;
	for(int i = 0 ; i < 26 ; i ++ )
	{
		if(root->next[i]!=NULL){
			root->next[i]->fail = root;
			q.push(root->next[i]);
		}
	}
    while(!q.empty()){
        acnode* tem = q.front();
        q.pop();
        for(int i = 0;i<26;i++){
            if(tem->next[i]!=NULL)
            {
                acnode *p;
                if(tem == root){
                    tem->next[i]->fail = root;
                }
                else
                {
                    p = tem->fail;
                    while(p!=NULL){
                        if(p->next[i]!=NULL){
                            tem->next[i]->fail = p->next[i];
                            break;
                        }
                        p=p->fail;
                    }
                    if(p==NULL)
                        tem->next[i]->fail = root;
                }
                q.push(tem->next[i]);
            }
        }
    }
}
//匹配函数
void ac_automation(char *ch)
{
    acnode *p = root;
    int len = strlen(ch);
    for(int i = 0; i < len; i++)
    {
        int x = ch[i] - 'a';
        while(p->next[x]==NULL && p != root)//没匹配到，那么就找fail指针。
            p = p->fail;
        p = p->next[x];
        if(!p)
            p = root;
        acnode *temp = p;
        while(temp != root)
        {
           if(temp->sum >= 0)
            /*
            在这里已经匹配成功了，执行想执行的操作即可，怎么改看题目需求+
            */
           {
               cnt += temp->sum;
               temp->sum = -1;
           }
           else break;
           temp = temp->fail;
        }
    }
}

int main()
{
    cnt = 0;
    int n;
    cin>>n;
    char c[101];
    root = newnode();
    for(int i = 0 ;i < n;i++){
        scanf("%s",c);
        Insert(c);
    }
    getfail();
    int m ;
    cin>> m;
    for(int i = 0;i<m;i++){
        scanf("%s",c);
        ac_automation(c);
    }
    cout<<cnt<<endl;
    return 0;
}

ICPC惨败，还是得努力啊！！！！

大唐忽悠
关注
  • 16
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
多模式字符串匹配 - AC自动机原理及实现
柚子树's Blog
05-22 873
给一个字符串，找出字符串中指定的单词，如果是单个词，我们可以通过暴力解法，从头开始遍历字符串，判断是否存在指定的单词，当然还有一种更优的解法，那就是KMP算法，通过构造next数组，保存匹配的中间状态，在查找单词失败时，不用退回到字符串开头重新进行匹配，实现了O(m+n)的时间复杂度。这种在一个字符串中找一个单词的匹配成为单模式匹配，如果要在一个字符串中寻找多个子串了，那就是将要谈到的多模式匹配，如何实现呢？对每个子串进行KMP匹配，当然也可以。但是有一种更为优秀的多模式匹配算法，那就是AC自动机算法。
KMP算法 AC自动机.ppt
03-22
KMP算法与AC自动机都是高效的字符串匹配算法。KMP算法专注于单个模式串的匹配，通过预处理模式串的部分匹配信息来减少不必要的比较；而AC自动机则用于多个关键词的搜索，通过构建字典树并添加失败指针来提高搜索效率...
13字符串匹配之KMP算法、Trie树、AC自动机
BruceLee1314的博客
05-22 553
1. KMP算法 KMP算法框架代码 时间复杂度：o(n+m)，其中m为next数组的长度，n为主串的长度。 空间复杂度：o(m)，其中m为next数组的长度。 class Solution{ public static int KMP(char[] a, int n, char[] b, int m){ int[] next = getNexts(b, m); int j = 0; for(int i=0; i<n; i++){
何恺明新作！打破自回归图像生成瓶颈，奥赛金牌得主参与
CV_Autobot的博客
06-27 287
作者|21# 编辑| 夕小瑶科技说点击下方卡片，关注“自动驾驶之心”公众号戳我-> 领取自动驾驶近15个方向学习路线>>点击进入→自动驾驶之心『计算机视觉』技术交流群本文只做学术分享，如有侵权，联系删文导读巧妙地借鉴了扩散模型的思想，成功地将自回归模型从矢量量化的束缚中解放出来，实现了连续值生成图像的突破。近日，深度学习领域的杰出研究者何恺明及其团队又放了个大招，推出其...
【字符串】AC自动机（kmp+字典树）hdu2222
weixin_43719720的博客
05-17 165
AC自动机：用公共前缀来减少查询时间，减少无谓的字符串比较时间，此处的公共前缀就是kmp的next数组构造。查询一个文本串中模式串出现的次数，需要构建字典树，而这里如何将两者联系到一起呢？就是将字典树上的next数组构造变成了给每个节点找fail指针。 关键点1：字典树构造 比方说我们有五个模板串：she shr say he her依次插入，根节点没有字母，标为0，插入she，从根...
字符串算法 | AC自动机算法
BurukeYou
04-11 1911
kmp
字符串 KMP算法与AC自动机算法
幸愉编程·信奥编程私教1v1
07-20 369
文章目录KMP题目集亲和串PeriodNumber Sequence KMP 题目集 亲和串 亲和串 题目大意 人随着岁数的增长是越大越聪明还是越大越笨，这是一个值得全世界科学家思考的问题,同样的问题Eddy也一直在思考，因为他在很小的时候就知道亲和串如何判断了，但是发现，现在长大了却不知道怎么去判断亲和串了，于是他只好又再一次来请教聪明且乐于助人的你来解决这个问题。 亲和串的定义是这样的：给定两个字符串s1和s2,如果能通过s1循环移位，使s2包含在s1中，那么我们就说s2 是s1的亲和串。 Input
从KMP、字典树到AC自动机，字符串的奋斗历程
颜之年
03-18 176
先贴几个板子，记录一下 kmp为单模匹配算法，这个博客讲的很好：https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html，透彻明了，其中next数组即为当前字符前已匹配的字符中最长的相同前后缀长度 贴上板子： //kmp和优化后的kmp #include <iostream> #include <cstring&g...
KMP算法 字典树 AC自动机（update）
zbbxndm的博客
05-15 264
KMP算法 AC自动机
字符串处理【AC自动机】 - 原理 AC自动机详解
谢谢你们的关注
12-08 1496
字符串处理【AC自动机】 - 原理 AC自动机详解
知识点十八：字符串匹配算法（Ⅳ）—— AC自动机
Mr_SCX的博客
01-21 547
前言 很多支持用户发表文本内容的网站，比如 BBS，大都会有敏感词过滤的功能，用来过滤掉用户输入的一些淫秽、反动、谩骂等内容。这个功能是怎么实现的呢？ 实际上，这个功能最基本的原理就是字符串匹配算法，也就是通过维护一个敏感词字典，当用户输入一段文字内容之后，通过字符串匹配算法，来查找用户输入的这段文字是否包含敏感词。如果有，就用“ *** ”把它替代掉。 前面几节我们学习了好几种字符串匹配算法，有...
字符串多模匹配算法之AC自动机理解心得.doc
05-07
这种算法的核心在于构建一种特殊的数据结构——字典树（也被称为 Failure Function 或 Failure Link），使得在匹配过程中，一旦当前字符无法匹配，能够迅速跳转到下一个可能匹配的位置，避免了对每个模式串单独进行...
AhoCorasickAutomation.rar_字符串字典_有限状态自动机
09-23
总结起来，Aho-Corasick算法是字符串匹配领域的一个强大工具，它通过字典树和有限状态自动机的结合，实现了对多个模式串的一次性高效查找。在处理大量字符串匹配问题时，该算法能够显著提高性能，节省计算资源。在...
swift-OC的字符串匹配库.包含KMP匹配AC多模字符串匹配.
08-15
AC自动机通过构建一个特殊的字典树（也称为失败链接树或AC树），使得在主串中搜索时，一旦一个模式不匹配，它能立即转移到下一个可能匹配的位置，而无需重新从头开始。这种算法特别适合在文本分析、搜索引擎和日志...
基本字符串全家桶（Hash,KMP,Trie,AC自动机）
08-11
本文将深入探讨四种重要的字符串处理技术：哈希（Hash）、KMP算法、Trie树（字典树）以及AC自动机。这些都是在解决字符串匹配问题时常用的方法，它们各有优缺点，适用于不同的场景。 1. **哈希（Hash）**： 哈希是...
智慧校园音视频系统整体解决方案-1PPT(24页).pptx
07-28
智慧校园整体解决方案是响应国家教育信息化政策，结合教育改革和技术创新的产物。该方案以物联网、大数据、人工智能和移动互联技术为基础，旨在打造一个安全、高效、互动且环保的教育环境。方案强调从数字化校园向智慧校园的转变，通过自动数据采集、智能分析和按需服务，实现校园业务的智能化管理。 方案的总体设计原则包括应用至上、分层设计和互联互通，确保系统能够满足不同用户角色的需求，并实现数据和资源的整合与共享。框架设计涵盖了校园安全、管理、教学、环境等多个方面，构建了一个全面的校园应用生态系统。这包括智慧安全系统、校园身份识别、智能排课及选课系统、智慧学习系统、精品录播教室方案等，以支持个性化学习和教学评估。 建设内容突出了智慧安全和智慧管理的重要性。智慧安全管理通过分布式录播系统和紧急预案一键启动功能，增强校园安全预警和事件响应能力。智慧管理系统则利用物联网技术，实现人员和设备的智能管理，提高校园运营效率。 智慧教学部分，方案提供了智慧学习系统和精品录播教室方案，支持专业级学习硬件和智能化网络管理，促进个性化学习和教学资源的高效利用。同时，教学质量评估中心和资源应用平台的建设，旨在提升教学评估的科学性和教育资源的共享性。 智慧环境建设则侧重于基于物联网的设备管理，通过智慧教室管理系统实现教室环境的智能控制和能效管理，打造绿色、节能的校园环境。电子班牌和校园信息发布系统的建设，将作为智慧校园的核心和入口，提供教务、一卡通、图书馆等系统的集成信息。 总体而言，智慧校园整体解决方案通过集成先进技术，不仅提升了校园的信息化水平，而且优化了教学和管理流程，为学生、教师和家长提供了更加便捷、个性化的教育体验。
基于Springboot和Vue的铁路订票管理系统源码 铁路订票管理系统代码（高分优秀毕业设计）
07-28
铁路订票管理系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
四足机器人 (2).pdf
最新发布
07-28
四足机器人 (2)
字符串处理算法详解：Hash、KMP、字典树、AC自动机与后缀数组
"这篇资料主要介绍了字符串处理算法，包括Hash、KMP、字典树、AC自动机和后缀数组等方法，适用于ACM/ICPC竞赛训练。内容涵盖Hash算法的基本思想、冲突解决策略，如Rabin-Karp算法以及Java中的HashMap应用，并给出了...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值