字符串经典匹配算法：KMP、Sunday与Shift-And

最新推荐文章于 2024-07-25 13:54:27 发布
最新推荐文章于 2024-07-25 13:54:27 发布
阅读量146 收藏
点赞数
分类专栏： 字符串匹配算法 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46571036/article/details/120846089
版权
暴力匹配算法

注：母串=文本串=长串

#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
using namespace std;
//字符串匹配值暴力匹配
// bool brute_force(const char *text,const char *pattern){
//     //传入两个参数，一个文本串一个模式串
//     for(int i=0;text[i];++i){
//         int flag = 1;//一开始设置表示能够匹配成功
//         for(int j=0;pattern[j];++j){
//             //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
//             if(text[i+j] == pattern[j]) continue;
//             //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
//             flag=0;
//             break;
//         }
//         if(flag == 1) return true;
//     }
//     //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
//     return false;
// }

//将函数返回值设定为int 可以返回文本串中查找模式串的起始位置在哪
int brute_force(const char *text,const char *pattern){
    //传入两个参数，一个文本串一个模式串
    for(int i=0;text[i];++i){
        int flag = 1;//一开始设置表示能够匹配成功
        for(int j=0;pattern[j];++j){
            //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
            if(text[i+j] == pattern[j]) continue;
            //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
            flag=0;
            break;
        }
        if(flag == 1) return i;
    }
    //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
    return -1;
}
#define TEST(func,s1,s2){\
    printf("%s(%s,%s)=%d\n",#func,s1,s2,func(s1,s2));\
}
int main(){
    char s1[100],s2[100];
    while(cin>>s1>>s2){
        TEST(brute_force,s1,s2);
    }
    return 0;
}
KMP算法：
#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
using namespace std;
//字符串匹配值暴力匹配
// bool brute_force(const char *text,const char *pattern){
//     //传入两个参数，一个文本串一个模式串
//     for(int i=0;text[i];++i){
//         int flag = 1;//一开始设置表示能够匹配成功
//         for(int j=0;pattern[j];++j){
//             //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
//             if(text[i+j] == pattern[j]) continue;
//             //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
//             flag=0;
//             break;
//         }
//         if(flag == 1) return true;
//     }
//     //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
//     return false;
// }

//将函数返回值设定为int 可以返回文本串中查找模式串的起始位置在哪
int brute_force(const char *text,const char *pattern){
    //传入两个参数，一个文本串一个模式串
    for(int i=0;text[i];++i){
        int flag = 1;//一开始设置表示能够匹配成功
        for(int j=0;pattern[j];++j){
            //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
            if(text[i+j] == pattern[j]) continue;
            //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
            flag=0;
            break;
        }
        if(flag == 1) return i;
    }
    //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
    return -1;
}

//KMP初始化的关键算法！！！
void GetNext(const char*pattern,int *next){
    next[0]=-1;//如果文本串的第一位和模式串的第一位匹配失败了则模式串的第一位应该跳到-1位 相当于虚拟头结点
    for(int i=1,j=-1;pattern[i];++i){
        while(j!=-1&&pattern[j+1]-pattern[i])j=next[j];
        if(pattern[j+1]==pattern[i])j+=1;
        next[i] = j;
        return ;
    }
}
int kmp(const char *text,const char *pattern){
    int n = strlen(pattern);
    //创建一个数组，作用是如果当前位置匹配不成功的时候我模式串跳到数组的第几位
    int *next = (int *)malloc(sizeof(int)*n);//开的长度应该和模式串的大小是一样的
    GetNext(pattern,next);//初始化next数组
    //接下来开始KMP算法的匹配过程
    for(int i=0,j=-1;text[i];i++){//j这里指向的是绿色区域（上次匹配成功的位置）
        //所以使用j+1位和i位置进行匹配，如果匹配不成功j就要向前跳
        while(j!=-1&&text[i]-pattern[j+1])j = next[j];
        //如果文本串的第i位等于了模式串的第j+1位，j+=1
        if(text[i] == pattern[j+1])j+=1;
        //判断当前是否匹配成功(如果模式串的最后一位（j位置）进入了绿色区域则说明全部模式串匹配成功)
        //判断成功了返回在文本串中模式串匹配成功的第一个位置
        if(pattern[j+1] == 0)return i-j;

    }
    return -1;
}


#define TEST(func,s1,s2){\
    printf("%s(%s,%s)=%d\n",#func,s1,s2,func(s1,s2));\
}
int main(){
    char s1[100],s2[100];
    while(cin>>s1>>s2){
        TEST(brute_force,s1,s2);
        TEST(kmp,s1,s2);
    }
    return 0;
}

KMP算法本质上是一个状态机的转换（来一个i转变一个j的值）最擅长用来处理流数据的转换

Sunday算法：

黄金对齐点位:在模式串和文本串匹配不成功时，文本串的匹配不成功的字符串的后一位与模式串从后向前找第一个与模式串相同字符的对其点位就是黄金点位。
Sunday大多用于查找文章中的单词，最理想时间复杂度为M/N（M为文本串的长度,N为模式串的长度）

#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
using namespace std;
//字符串匹配值暴力匹配
// bool brute_force(const char *text,const char *pattern){
//     //传入两个参数，一个文本串一个模式串
//     for(int i=0;text[i];++i){
//         int flag = 1;//一开始设置表示能够匹配成功
//         for(int j=0;pattern[j];++j){
//             //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
//             if(text[i+j] == pattern[j]) continue;
//             //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
//             flag=0;
//             break;
//         }
//         if(flag == 1) return true;
//     }
//     //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
//     return false;
// }

//将函数返回值设定为int 可以返回文本串中查找模式串的起始位置在哪
int brute_force(const char *text,const char *pattern){
    //传入两个参数，一个文本串一个模式串
    for(int i=0;text[i];++i){
        int flag = 1;//一开始设置表示能够匹配成功
        for(int j=0;pattern[j];++j){
            //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
            if(text[i+j] == pattern[j]) continue;
            //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
            flag=0;
            break;
        }
        if(flag == 1) return i;
    }
    //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
    return -1;
}

//KMP初始化的关键算法！！！
void GetNext(const char*pattern,int *next){
    next[0]=-1;//如果文本串的第一位和模式串的第一位匹配失败了则模式串的第一位应该跳到-1位 相当于虚拟头结点
    for(int i=1,j=-1;pattern[i];++i){
        while(j!=-1&&pattern[j+1]-pattern[i])j=next[j];
        if(pattern[j+1]==pattern[i])j+=1;
        next[i] = j;
        return ;
    }
}
int kmp(const char *text,const char *pattern){
    int n = strlen(pattern);
    //创建一个数组，作用是如果当前位置匹配不成功的时候我模式串跳到数组的第几位
    int *next = (int *)malloc(sizeof(int)*n);//开的长度应该和模式串的大小是一样的
    GetNext(pattern,next);//初始化next数组
    //接下来开始KMP算法的匹配过程
    for(int i=0,j=-1;text[i];i++){//j这里指向的是绿色区域（上次匹配成功的位置）
        //所以使用j+1位和i位置进行匹配，如果匹配不成功j就要向前跳
        while(j!=-1&&text[i]-pattern[j+1])j = next[j];
        //如果文本串的第i位等于了模式串的第j+1位，j+=1
        if(text[i] == pattern[j+1])j+=1;
        //判断当前是否匹配成功(如果模式串的最后一位（j位置）进入了绿色区域则说明全部模式串匹配成功)
        //判断成功了返回在文本串中模式串匹配成功的第一个位置
        if(pattern[j+1] == 0)return i-j;

    }
    return -1;
}

//sunday算法记录的是每一种字符在模式串中最后出现的位置
int sunday(const char *text,const char* pattern){
    #define BASE 256
    int n=strlen(text),m,last_pos[BASE];//n表示文本串的长度,m表示模式串的长度,last_pos表示可以表示每一个字节的所有状态
    for(int i=0;i<BASE;i++) last_pos[i] = -1;//开始将每个位置初始化为-1
    for(m = 0;pattern[m];++m){
        last_pos[pattern[m]] = m;
    }
    for(int i=0;i+m<n;i+=(m-last_pos[text[i+m]])){
        int flag = 1;
        for(int j=0;pattern[j];++j){
            if(text[i+j] == pattern[j])continue;
            flag = 0;
            break;
        }
        if(flag) return i;
    }
    return -1;
}


#define TEST(func,s1,s2){\
    printf("%s(%s,%s)=%d\n",#func,s1,s2,func(s1,s2));\
}
int main(){
    char s1[100],s2[100];
    while(cin>>s1>>s2){
        TEST(brute_force,s1,s2);
        TEST(kmp,s1,s2);
        TEST(sunday,s1,s2);
    }
    return 0;
}
Shift-And算法：

将模式串— 预处理—>信息+文本串——>匹配过程
预处理：将模式串处理成二进制数据
时间复杂度为O[n];
此算法底层原理同样设计状态机的转换所以也适合流数据的处理。
适合处理每个字符多种字符同时满足的场景

#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<vector>
using namespace std;
//字符串匹配值暴力匹配
// bool brute_force(const char *text,const char *pattern){
//     //传入两个参数，一个文本串一个模式串
//     for(int i=0;text[i];++i){
//         int flag = 1;//一开始设置表示能够匹配成功
//         for(int j=0;pattern[j];++j){
//             //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
//             if(text[i+j] == pattern[j]) continue;
//             //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
//             flag=0;
//             break;
//         }
//         if(flag == 1) return true;
//     }
//     //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
//     return false;
// }

//将函数返回值设定为int 可以返回文本串中查找模式串的起始位置在哪
int brute_force(const char *text,const char *pattern){
    //传入两个参数，一个文本串一个模式串
    for(int i=0;text[i];++i){
        int flag = 1;//一开始设置表示能够匹配成功
        for(int j=0;pattern[j];++j){
            //如果文本串的i+j位置和模式串的第j位相等了就继续向下判断
            if(text[i+j] == pattern[j]) continue;
            //另一种情况就是文本串和模式串相对应的位置不匹配就设定flag=0
            flag=0;
            break;
        }
        if(flag == 1) return i;
    }
    //此时用模式串遍历完模式串的每一个位置都没有匹配的则返回false
    return -1;
}

//KMP初始化的关键算法！！！
void GetNext(const char*pattern,int *next){
    next[0]=-1;//如果文本串的第一位和模式串的第一位匹配失败了则模式串的第一位应该跳到-1位 相当于虚拟头结点
    for(int i=1,j=-1;pattern[i];++i){
        while(j!=-1&&pattern[j+1]-pattern[i])j=next[j];
        if(pattern[j+1]==pattern[i])j+=1;
        next[i] = j;
        return ;
    }
}
int kmp(const char *text,const char *pattern){
    int n = strlen(pattern);
    //创建一个数组，作用是如果当前位置匹配不成功的时候我模式串跳到数组的第几位
    int *next = (int *)malloc(sizeof(int)*n);//开的长度应该和模式串的大小是一样的
    GetNext(pattern,next);//初始化next数组
    //接下来开始KMP算法的匹配过程
    for(int i=0,j=-1;text[i];i++){//j这里指向的是绿色区域（上次匹配成功的位置）
        //所以使用j+1位和i位置进行匹配，如果匹配不成功j就要向前跳
        while(j!=-1&&text[i]-pattern[j+1])j = next[j];
        //如果文本串的第i位等于了模式串的第j+1位，j+=1
        if(text[i] == pattern[j+1])j+=1;
        //判断当前是否匹配成功(如果模式串的最后一位（j位置）进入了绿色区域则说明全部模式串匹配成功)
        //判断成功了返回在文本串中模式串匹配成功的第一个位置
        if(pattern[j+1] == 0)return i-j;

    }
    return -1;
}

//sunday算法记录的是每一种字符在模式串中最后出现的位置
int sunday(const char *text,const char* pattern){
    #define BASE 256
    int n=strlen(text),m,last_pos[BASE];//n表示文本串的长度,m表示模式串的长度,last_pos表示可以表示每一个字节的所有状态
    for(int i=0;i<BASE;i++) last_pos[i] = -1;//开始将每个位置初始化为-1
    for(m = 0;pattern[m];++m){
        last_pos[pattern[m]] = m;
    }
    for(int i=0;i+m<n;i+=(m-last_pos[text[i+m]])){
        int flag = 1;
        for(int j=0;pattern[j];++j){
            if(text[i+j] == pattern[j])continue;
            flag = 0;
            break;
        }
        if(flag) return i;
    }
    return -1;
}

int shift_and(const char*text,const char*pattern){
    //第一步现将模式串处理成相关字符的编码
    int code[256]={0};
    int n=0;
    for(n=0;pattern[n];++n)code[pattern[n]] |=(1<<n);
    int p = 0;
    for(int i=0;text[i];i++){
        p=(p<<1|1)&code[text[i]];
        if(p&(1<<(n-1)))return i-n+1;
    }
    return -1;
}

#define TEST(func,s1,s2){\
    printf("%s(%s,%s)=%d\n",#func,s1,s2,func(s1,s2));\
}
int main(){
    char s1[100],s2[100];
    while(cin>>s1>>s2){
        TEST(brute_force,s1,s2);
        TEST(kmp,s1,s2);
        TEST(sunday,s1,s2);
        TEST(shift_and,s1,s2);
    }
    return 0;
}
WC-fantastic687
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串的匹配（KMP和sunday算法详解）
qq_42058590的博客
11-19 1129
之前一直用的kmp来做字符串的匹配题目，直到今日才知道还有sunday这种高效又简单的算法，虽然不能百分之一万的保证准确性，我也没有看sunday算法的相关证明，不过学习了之后确实觉得巧妙，今天我就好好写写这两种算法。 第一 经典的kmp： kmp的核心就是求next数组，而求next数组，主要就是以下几步： 每一个next[i]的值都代表着i前面的字符的最大回文长度。因此，我们设next[0...
KMP算法：高效字符串匹配算法详解
04-03
KMP算法（Knuth-Morris-Pratt算法）是一种高效的字符串匹配算法，由Donald Knuth、Vaughan Pratt和James H. Morris共同发明。KMP算法通过使用一个称为“部分匹配表”或“next数组”的数组来减少字符串匹配过程中的...
字符串匹配算法-Sunday/KMP/Shift-And算法
CHW的博客
10-27 119
　　最近这两天学了学有关字符串匹配的算法，据说字符串匹配问题是计算机科学领域中研究最为广泛的问题之一，用于信息类的领域...反正有关字符串的东西确实很重要，比如想从事大数据，自然语言处理，人工智能，机器学习等方面工作的童鞋来说，这些基本的有关字符串的算法必会噢，同时有关字符串的算法，题目，应用来说，确实体现智慧啊（有的比较不太好理解，生涩难懂） 　　好了，闲话就哔哔到这，上干货... 　　首先...
【算法09】经典匹配算法: KMP、Sunday与ShiftAnd
weixin_55252589的博客
09-17 600
如果文本串中，出现了模式串中根本没出现过的字符，那么模式串应该向后移动整个模式串的长度。sunday算法适合处理在一篇文章中，查找一个单词。如果每次都向后这样子跳啊，sunday算法的时间复杂度最好能到达O(n/m)，m是单词的长度，n是文章的长度。所以sunday算法在实际场景中是远优于kmp，远优于暴力匹配的。
经典字符串匹配算法-KMP、Sunday、shift-And基本思想、边界处理与编程技巧、代码实现
记录与分享AI资料与学习过程
03-09 759
本人按照暴力匹配、Sunday、shift-And、KMP。希望能够由简到难，明晰思想，厘清逻辑以及熟悉一些编程的处理方式，希望能够化解算法思想缺失和编程能力不足导致的算法进阶迷茫。Sunday算法不再逐个位置比较，通过对pattern串的元素情况的分析，向后跳一定长度，减少了计算量。shift-And将pattern串的每个元素进行按位编码，将匹配问题转换为高位的与运算，用p来记录当前高位的匹配情况。KMP算法利用了pattern字符串的前缀和后缀信息，找到未匹配字符前最长的相同前缀和后缀信息来进行跳转
字符串单模匹配算法 RK / BM / Sunday / SHIFT-AND / KMP
四库全书的酷
04-24 487
文章目录单模匹配问题RK算法存在的问题简单实现BM算法坏字符方法好后缀方法坏字符+好后缀配合。Sunday算法SHIFT-AND算法（位运算）KMP算法 单模匹配问题 单模匹配问题：一个字符串和另一个字符串之间的包含关系确认的问题， 假设求解字符串A中是否包含字符串B。那么字符串A就是文本串，字符串B就是模式串。 也就是求解文本串中是否含有模式串的问题。 前置条件： 文本串的长度为n； 模式串的长度为m； n>=m>=0; RK算法 Rabin-Karp算法：就是利用hash思想，我们通过哈
字符串经典匹配算法之shift_and算法
qq_34603425的博客
12-11 592
字符串经典匹配算法之shift_and算法。shift_and算法的总体思路是把模式串预处理成一种特殊编码形式，然后根据这种编码形式去逐位匹配文本串。shift_and算法的时间复杂度为O(n)，可以用于处理流式数据，同时可以用于处理复杂的正则表达式，比如模式串的每一位可能是多个字符。因为shift_and算法的预处理兼容性非常强。
字符串匹配算法——暴力 + KMP +SUNDAY + 哈希 + SHIFT_AND
aMonstere的博客
01-30 303
单模匹配 暴力匹配 只有一个模式串机型匹配 模式串：待查找的字符串 依次性对齐，模式串的第一位和母串的每一位开始匹配，直到发现母串中的一部分跟模式串匹配 单模匹配问题，顾名思义，只有一个模式串 依次对齐模式串和文本串的每一位，直到匹配成功 关键：不重不漏的找到答案 int brute_force(const char *s, const char *t) { for (int i = 0; s[i]; i++) { int flag = 1; for (int j
字符串匹配——朴素算法、KMP算法
程序员养成日记
08-18 346
字符串匹配（string match)是在实际工程中经常会碰到的问题，通常其输入是原字符串(String)和子串（又称模式，Pattern)组成，输出为子串在原字符串中的首次出现的位置。通常精确的字符串搜索算法包括朴素搜索算法，KMP, BM(Boyer Moore), sunday, robin-karp 以及 bitap。下面分析朴素搜索算法和KMP这两种方法并给出其实现。假设原字符T串长度N...
字符串的模式匹配详解--BF算法与KMP算法
09-04
字符串的模式匹配是一种重要的计算机科学领域中的算法，用于在给定的文本字符串中查找是否存在一个特定的模式字符串。本文主要探讨两种经典的模式匹配算法：BF（Brute Force，暴力匹配）算法和KMP（Knuth-Morris-...
kmp算法-使用kmp算法在Golang中实现字符串匹配.zip
05-16
在这个例子中，`getPartialMatchTable`函数用于生成部分匹配表，而`KMPSearch`函数实现了实际的字符串匹配。输入主串`s`和模式串`p`，返回一个包含所有匹配位置的数组。 Golang作为一个现代化的编程语言，提供了...
KMP(字符串匹配)算法
08-20
程序开发过程中的字符串匹配算法很多，这里出了算法的程序源代码，包括C#，C++, Delphi代码,大家直接下载就可以拷贝到自己程序中使用。
kmp算法-基于Python+kmp算法实现模糊文本字符串匹配.zip
03-22
《Python实现KMP算法：模糊文本字符串匹配》 在信息技术领域，字符串匹配是常见的操作，尤其是在文本处理、数据挖掘和搜索引擎优化中。其中，KMP（Knuth-Morris-Pratt）算法是一种高效的字符串匹配算法，它能有效地...
算法力扣刷题记录 五十九【450.删除二叉搜索树中的节点】
danaaaa的博客
07-25 1238
删除节点，在左右子树不为空的情况，处理稍微复杂。
代码随想录算法训练营第二十二天|回溯算法part01
qq_43456971的博客
07-25 698
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
河南萌新联赛2024第（二）场：南阳理工学院
a13997460860的博客
07-25 1290
这场比赛里面出到了很多的题，都是需要很多的时间去写，主要考察到了代码的实现能力，与codeforces里面的题有些差距。codeforces打多了还是有点不习惯的。题挺好的，尤其是H题感觉很考代码实现能力与STL的使用熟练度。多写写这样的题还是对我们很有好处的。只不过前三题都太水了，没有一点难度。
大模型算法备案流程最详细说明【流程+附件】
cybtec的博客
07-25 955
大模型备案,模型服务协议 1.大模型备案 2.大模型算法备案 3.大模型网信办备案 4.网信办大模型备案 5.AI大模型备案制度 6.大模型 备案 7.大模型备案要求 8.大模型备案管理制度 9.算法备案和大模型备案区别
代码随想录算法训练营第22天-leetcode-回溯算法part01：
最新发布
weixin_65180740的博客
07-25 1108
column的赋值过程：*column是正常数组，先为*column开辟空间，*column【第几个，<returnsize】=ans【第几个】有多少个二层元素。示例: 输入: n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4],放入path的过程需要用循环一个个放入，直接=path的话，后面会随path修改而修改。示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]
高效两向字符串匹配算法：介于KMP与Boyer-Moore间的简化解决方案
"Two-Way String Matching算法是1991年由Maxime Crochemore和Dominique Perrin提出的一种创新的字符串匹配方法，它位于经典的Knuth-Morris-Pratt (KMP)算法和Boyer-Moore算法之间，具有独特的性能特点。这个算法的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值