C刷题：LeetCode 752. 打开转盘锁 （中等） || BFS广搜详解 （2）

最新推荐文章于 2022-07-03 10:23:19 发布
最新推荐文章于 2022-07-03 10:23:19 发布
阅读量228 收藏
点赞数
分类专栏： LeetCode刷题 文章标签： leetcode 算法 数据结构 转盘锁 广度搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17256689/article/details/118692458
版权

C刷题：LeetCode 752. 打开转盘锁 （中等）

作者：来知晓
公众号：来知晓
刷题交流QQ群：444172041

接上一篇博客：C刷题：LeetCode 752. 打开转盘锁 （中等） || BFS广搜详解 （1）

Hash版本

添加HASH数据结构，熟悉uthash的使用，添加约束条件。

主要约束条件：

  • 不走回头路，比如往前转动了一次的结果，不允许再往后转动回去
  • 不能越过deadends
  • 加上终止条件，一旦匹配到target就返回

不走回头路，比如往前转动了一次的结果，不允许再往后转动回去。如初始状态0000，转动一次变为1000，再转动一次不能转回去变为0000。实现的主要思路是，增加一个hash表visit记录所有已经有的遍历结果，如果出现相同的则跳过并且不记录。主要用uthash哈希表的O(1)查找功能，减少查找时间。

不能越过deadends，也是类似visit的hash表查找思路实现。hash表时间复杂度为O(1)，不过是以空间换时间，减少时间的同时会增长空间。

终止条件，由于该思路本身就是从转动次数0开始往外扩展的，类似一种贪心算法思想，每步都是最优的了。一旦匹配上目标，当前转动次数就是最小的，所以可以直接返回。

提交通过的hash版本代码如下：

#define STR_SIZE 5
#define STR_LEN 4
int g_curLevelCnt;

typedef struct HashTable {
    char str[STR_SIZE]; // key
    UT_hash_handle hh; // table head
} StruHashTable;

typedef struct QueList {
    int cnt; // 转动次数
    char *s; // 当前密码
    struct QueList *next; // 下个可能密码
} StruQueList, *PtrStruQueList;

char* AddOne(char *in, int j)
{
    char *res = (char *)malloc(sizeof(char) * STR_SIZE);
    if (res == NULL) {
        return NULL;
    }
    memcpy(res, in, STR_SIZE);
    char ch = res[j];
    if (ch == '9') {
        res[j] = '0';
        return res;
    }
    res[j] = ch + 1;
    return res;
}

char* MinusOne(char *in, int j)
{
    char *s = (char *)malloc(sizeof(char) * STR_SIZE);
    if (s == NULL) {
        return NULL;
    }
    memcpy(s, in, STR_SIZE);
    char ch = s[j];
    if (ch == '0') {
        s[j] = '9';
        return s;
    }
    s[j] = ch - 1;
    return s;
}

void Init(StruQueList **pQue, char *s, int cnt)
{
    (*pQue) = (PtrStruQueList)malloc(sizeof(StruQueList));
    (*pQue)->cnt = cnt;
    char *str = (char *)malloc(sizeof(char) * STR_SIZE);
    if (str == NULL) {
        return;
    }
    memcpy(str, s, STR_SIZE);
    (*pQue)->s = str;
    (*pQue)->next = NULL;
    g_curLevelCnt++;
}

// 大于0，则表示匹配成功，返回转动次数
// 等于0，则表示无异常
// 小于0，则表示出错
int NodeExpand(StruQueList **queList, StruQueList **ptrQueListLastNode, char *target, StruHashTable **ptrDead, StruHashTable **ptrVisit)
{
    int i;
    char *s;
    StruHashTable *hashTmp1, *hashTmp2;

    // 转动1次, 当前节点演变出8种可能
    char *cur = (*queList)->s;
    int cnt = (*queList)->cnt;
    for (i = 0; i < 4; i++) {
        s = AddOne(cur, i);
        // 如果与target匹配
        if (strcmp(s, target) == 0) { // 终止条件
            return cnt + 1;
        }

        // 如果在deadends
        HASH_FIND(hh, *ptrDead, s, sizeof(char) * STR_SIZE, hashTmp1);
        // 如果已遍历
        HASH_FIND(hh, *ptrVisit, s, sizeof(char) * STR_SIZE, hashTmp2);
        if (hashTmp1 == NULL && hashTmp2 == NULL) { // 不在dead里也没在visit里
            Init(&(*ptrQueListLastNode)->next, s, cnt + 1);
            *ptrQueListLastNode = (*ptrQueListLastNode)->next;
            hashTmp1 = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
            if (hashTmp1 == NULL) {
                return -1;
            }
            memcpy(hashTmp1->str, s, STR_SIZE);
            HASH_ADD(hh, *ptrVisit, str, sizeof(char) * STR_SIZE, hashTmp1);
            // printf("%s\n", s);
        } else {
            free(s);
        }

        s = MinusOne(cur, i);
        // 如果与target匹配
        if (strcmp(s, target) == 0) { // 终止条件
            return cnt + 1;
        }
        // 如果在deadends
        HASH_FIND(hh, *ptrDead, s, sizeof(char) * STR_SIZE, hashTmp1);
        // 如果已遍历
        HASH_FIND(hh, *ptrVisit, s, sizeof(char) * STR_SIZE, hashTmp2);
        if (hashTmp1 == NULL && hashTmp2 == NULL) { // 不在dead里也没在visit里
            Init(&(*ptrQueListLastNode)->next, s, cnt + 1);
            *ptrQueListLastNode = (*ptrQueListLastNode)->next;
            hashTmp1 = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
            if (hashTmp1 == NULL) {
                return -1;
            }
            memcpy(hashTmp1->str, s, STR_SIZE);
            HASH_ADD(hh, *ptrVisit, str, sizeof(char) * STR_SIZE, hashTmp1);
            // printf("%s\n", s);
        } else {
            free(s);
        }
    }
    // printf("\n");
    return 0;
}

// 按队列和BFS的方法来表达每次只转一次，对应的所有可能
int openLock(char ** deadends, int deadendsSize, char * target)
{
    char cur[STR_SIZE] = "0000"; // 初始值
    int i, ret;

    // special case
    if (strcmp(cur, target) == 0) {
        return 0;
    }

    // 初始化hash
    StruHashTable *dead = NULL; // 表头最开始都为空
    StruHashTable *hashTmp;
    for (i = 0; i < deadendsSize; i++) {
        HASH_FIND(hh, dead, deadends[i], sizeof(char) * STR_SIZE, hashTmp); // 键值所占空间sizeof(char) * 5
        if (hashTmp == NULL) { // 之前未出现
            hashTmp = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
            if (hashTmp == NULL) {
                return -1;
            }
            memcpy(hashTmp->str, deadends[i], STR_SIZE);
            HASH_ADD(hh, dead, str, sizeof(char) * STR_SIZE, hashTmp); // str表示操作结构体中的键值，追加到hashtable中
        }
    }

    // special case
    HASH_FIND(hh, dead, target, sizeof(char) * STR_SIZE, hashTmp);
    if (hashTmp != NULL) {
        return -1;  // deanends contain target
    }
    HASH_FIND(hh, dead, cur, sizeof(char) * STR_SIZE, hashTmp);
    if (hashTmp != NULL) {
        return -1;  // deanends contain target
    }

    // 初始化队列 0000
    StruHashTable *visit = NULL; // 表头最开始都为空
    PtrStruQueList queList, queListCurLevelLast, queListLastNode;
    queList = (PtrStruQueList)malloc(sizeof(StruQueList));
    if (queList == NULL) {
        return -1; // if malloc is failed
    }
    g_curLevelCnt = 0;
    Init(&queList, cur, 0);
    hashTmp = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
    if (hashTmp == NULL) {
        return -1;
    }
    memcpy(hashTmp->str, queList->s, STR_SIZE);
    // printf("%p\n", visit);
    HASH_ADD(hh, visit, str, sizeof(char) * STR_SIZE, hashTmp); // 增加一个已遍历状态
    // printf("%p\n", visit);

    g_curLevelCnt = 0;
    queListLastNode = queList;
    ret = NodeExpand(&queList, &queListLastNode, target, &dead, &visit);
    if (ret > 0) { // 终止条件
        return ret;
    }
    queListCurLevelLast = queListLastNode;
    queList = queList->next;

    // 从所有层每个节点中迭代新的可能
    while (queList != NULL) {
        // 遍历当前层所有节点
        int len = g_curLevelCnt;
        g_curLevelCnt = 0;
        for (i = 0; i < len; i++) {
            ret = NodeExpand(&queList, &queListLastNode, target, &dead, &visit);
            if (ret > 0) { // 终止条件
                return ret;
            }
            queList = queList->next;
        }
    }

    return -1; // 遍历完所有无匹配
}

Hash版本优化

代码精简：删除冗余信息和提炼重复代码为独立子函数。

  • 删除合并重复代码减少层序遍历冗余
  • 将超50行的代码拆分成子功能函数
  • 替换魔鬼数字为有意义的宏命名
  • 优化while循环加lastNode判断为for循环，采用全局变量计数当前层个数作为len

主要变化的代码如下：

void InitDeadHash(char **deadends, int deadendsSize, StruHashTable **ptrDead)
{
    int i;
    StruHashTable *hashTmp;
    for (i = 0; i < deadendsSize; i++) {
        HASH_FIND(hh, *ptrDead, deadends[i], sizeof(char) * STR_SIZE, hashTmp); // 键值所占空间sizeof(char) * 5
        if (hashTmp == NULL) { // 之前未出现
            hashTmp = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
            if (hashTmp == NULL) {
                return;
            }
            memcpy(hashTmp->str, deadends[i], STR_SIZE);
            HASH_ADD(hh, *ptrDead, str, sizeof(char) * STR_SIZE, hashTmp); // str表示操作结构体中的键值，追加到hashtable中
        }
    }
    return;
}

void InitQueAndVisitHash(char *cur, StruQueList **ptrQueList, StruHashTable **ptrVisit)
{
    StruHashTable *hashTmp;
    *ptrQueList = (PtrStruQueList)malloc(sizeof(StruQueList));
    if (*ptrQueList == NULL) {
        return; // if malloc is failed
    }
    g_curLevelCnt = 0;
    Init(ptrQueList, cur, 0);
    hashTmp = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
    if (hashTmp == NULL) {
        return;
    }
    memcpy(hashTmp->str, (*ptrQueList)->s, STR_SIZE);
    HASH_ADD(hh, *ptrVisit, str, sizeof(char) * STR_SIZE, hashTmp); // 增加一个已遍历状态
    return;
}

int DealCurStr(char *s, char *target, int cnt, StruQueList **ptrQueListLastNode, StruHashTable **ptrDead, StruHashTable **ptrVisit)
{
    StruHashTable *hashTmp1, *hashTmp2;
    // 如果与target匹配
    if (strcmp(s, target) == 0) { // 终止条件
        return cnt + 1;
    }

    // 如果在deadends
    HASH_FIND(hh, *ptrDead, s, sizeof(char) * STR_SIZE, hashTmp1);
    // 如果已遍历
    HASH_FIND(hh, *ptrVisit, s, sizeof(char) * STR_SIZE, hashTmp2);
    if (hashTmp1 == NULL && hashTmp2 == NULL) { // 不在dead里也没在visit里
        Init(&(*ptrQueListLastNode)->next, s, cnt + 1);
        *ptrQueListLastNode = (*ptrQueListLastNode)->next;
        hashTmp1 = (StruHashTable *)malloc(sizeof(StruHashTable)); // 增加一个hash节点
        if (hashTmp1 == NULL) {
            return -1;
        }
        memcpy(hashTmp1->str, s, STR_SIZE);
        HASH_ADD(hh, *ptrVisit, str, sizeof(char) * STR_SIZE, hashTmp1);
        // printf("%s\n", s);
    } else {
        free(s);
    }
    return 0;
}

// 大于0，则表示匹配成功，返回转动次数
// 等于0，则表示无异常
// 小于0，则表示出错
int NodeExpand(StruQueList *queList, StruQueList **ptrQueListLastNode, char *target, StruHashTable **ptrDead, StruHashTable **ptrVisit)
{
    int i, ret;
    char *s;

    // 转动1次, 当前节点演变出8种可能
    char *cur = queList->s;
    int cnt = queList->cnt;
    for (i = 0; i < 4; i++) {
        s = AddOne(cur, i);
        ret = DealCurStr(s, target, cnt, ptrQueListLastNode, ptrDead, ptrVisit);
        if (ret > 0) {
            return ret;
        }

        s = MinusOne(cur, i);
        ret = DealCurStr(s, target, cnt, ptrQueListLastNode, ptrDead, ptrVisit);
        if (ret > 0) {
            return ret;
        }
    }
    // printf("\n");
    return 0;
}

int LevelTraverse(StruQueList *queList, StruQueList **ptrQueListLastNode, char *target, StruHashTable **ptrDead, StruHashTable **ptrVisit)
{
    // 得到两个队列的指针，一个是当前指向，一个是层级对应的新开头
    // 从所有层每个节点中迭代新的可能
    int i, ret;
    while (queList != NULL) {
        // 遍历当前层所有节点
        int len = g_curLevelCnt;
        g_curLevelCnt = 0;
        for (i = 0; i < len; i++) {
            ret = NodeExpand(queList, ptrQueListLastNode, target, ptrDead, ptrVisit);
            if (ret > 0) { // 终止条件
                return ret;
            }
            queList = queList->next;
        }
        // printf("\n\n");
    }

    return 0;
}

// 按队列和BFS的方法来表达每次只转一次，对应的所有可能
int openLock(char ** deadends, int deadendsSize, char * target)
{
    char cur[STR_SIZE] = "0000"; // 初始值
    int ret;

    // special case
    if (strcmp(cur, target) == 0) {
        return 0;
    }

    // 初始化dead hash
    StruHashTable *dead = NULL; // 表头最开始都为空
    StruHashTable *hashTmp, *hashTmp1, *hashTmp2;
    InitDeadHash(deadends, deadendsSize, &dead);

    // special case
    HASH_FIND(hh, dead, target, sizeof(char) * STR_SIZE, hashTmp1);
    HASH_FIND(hh, dead, cur, sizeof(char) * STR_SIZE, hashTmp2);
    if (hashTmp1 != NULL || hashTmp2 != NULL) {
        return -1;  // deanends contain target
    }

    // 初始化队列0000和visit hash
    StruHashTable *visit = NULL; // 表头最开始都为空
    PtrStruQueList queList, queListLastNode;
    InitQueAndVisitHash(cur, &queList, &visit);

    queListLastNode = queList;
    ret = LevelTraverse(queList, &queListLastNode, target, &dead, &visit);
    if (ret > 0) { // 终止条件
        return ret;
    }
    return -1; // 遍历完所有无匹配
}

展望

  • 可参考官方解答写法，简化openLock()中循环代码实现
  • 可采用双向BFS进一步提高效率
  • 可采用启发式搜索A*算法进一步提高效率
来知晓
关注
专栏目录
【LeetCode】第752题——打开转盘锁（难度：中等）
Se7en_Dayz的博客
06-25 315
【LeetCode】第752题——打开转盘锁（难度：中等）题目描述解题思路代码详解注意点 题目描述 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。 锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。 列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任
【LeetCode - 752】打开转盘锁
学哥斌的博客
06-22 276
【中等】BFS
Leetcode 752.打开转盘锁 C语言
Growth Of Dating
03-31 500
很明显的状态转移问题，这类问题利用bfs求最短路径都能得到有效的解决，基本都是体力活了。 思考一：如何判断死亡数字 Solution: 很简单的问题，但是为了提高效率一定要对deadends去重。 bool unlocked(char** deadends,int deadendsSize,char* s){ int i; for(i = 0 ; i < deadendsS...
C刷题：LeetCode 752. 打开转盘锁 （中等） || BFS广搜详解 （1）
来知晓的博客
07-11 173
C刷题：LeetCode 752. 打开转盘锁 （中等）思路分析原始版本版本一：BFS穷举所有可能版本二：找到target即终止Hash版本Hash版本优化展望 你以为的中等题，结果用了A*算法，没有现成的数据结构，用C语言实现，不亚于难题，哈哈连官方答案里都懒得写C版本了。。。所以，我就不搞那么复杂啦，就用BFS一步步把分析的思路记录与此吧。 思路分析 先实现最简单的，遍历穷举所有可能 接着实现BFS遍历找到target 再加约束deadends跳过 + 最小次数 实现子函数加减功能 原始版本 独
c/c++ 力扣LeetCode 752.打开转盘锁
镭射瓶的博客
06-25 189
题目链接： 力扣 752.打开转盘锁 不想戳的看下图： 算法详解： 普通BFS搜索时，每一层的搜索节点数量会爆炸级增加。假设每一次搜索都有 nn 个新的状态，并假设从起点到目标路径长为 mm，那就要搜索：n+n2+n3+…+n^mn+n2 +n3 +…+nm 个状态，状态数就是 n^{m+1}n m+1 数量级的。 所以，此时，双向的BFS就派上用场了。 原理： 双向BFS是同时从起点和终点两个方向开始搜索，一旦搜索到另一个方向已经搜索过的位置（或者说出现某个状态被两个方向均访问到了），就意味着找到了一条
队列 & 栈//打开转盘锁
11-10 111
你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字：'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'。每个拨轮可以自由旋转：例如把'9'变为'0'，'0'变为'9'。每次旋转都只能旋转一个拨轮的一位数字。 锁的初始数字为'0000'，一个代表四个拨轮的数字的字符串。 列表d...
LeetCode:刷题刷题刷题...我是一个刷题将，刷题本领看情况
03-26
LeetCode是一个广受欢迎的在线平台，它提供了大量的编程挑战，涵盖了C++在内的多种编程语言。本文将深入探讨LeetCode刷题对于学习C++的重要性和具体实践方法。 首先，C++是一种强大的、通用的编程语言，广泛应用于...
leetcode刷题账号-leetcode:leetcode刷题笔记https://leetcode-cn.com/itagn/
07-06
该资源可能是一个包含LeetCode刷题笔记的压缩包，名为"leetcode-master"，可能是用户整理的一套完整的刷题记录或解决方案。"系统开源"的标签可能意味着这个笔记或者是相关的代码实现是公开的，允许他人学习和参考。 ...
LeetCode：热烈欢迎访问我的网站：https：www.zengqiang.org ｜目录：
01-30
LeetCode：热烈欢迎访问我的网站：https：www.zengqiang.org ｜目录：
leetcode:leetcode刷题:pencil:
05-02
LeetCode Leetcode solutions in C++ 11 NO. Title Solution Note Difficulty Tag 1 Easy 数组 | 哈希表 2 Medium 链表 | 数学 3 Medium 字符串 4 Hard 数组 | 二分查找 5 Medium 字符串 | 动态规划 7 反转整数 C++ ...
leetcode:LeetCode Top 100 Liked Questions | Top Interview Questions | LeetCode 用户最喜欢的100题 | 面试最容易被问到的题
05-10
LeetCode 指南 语言: Java 说明： 每道题在代码头部都添加了我的解题思路和批注，Eg: /***** * 287. Find the Duplicate Number * 题意：n+1个数属于[1~n]，找出重复的那个数 * 难度：Medium * 分类：Array, ...
LC 打开转盘锁(C++ 实现)
明天，做什么好呢
10-10 772
问题描述 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。 锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。 列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋转。 字符串 target 代表可
leetcode 752. 打开转盘锁 c代码
fuyuande的博客
10-30 758
先看题目： 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。 每个拨轮可以自由旋转：例如把 '9' 变为 '0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。 锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。 列表 deadends 包含了一组...
打开转盘锁 Open the Lock
Cui's Blog
10-07 309
文章目录打开转盘锁 Open the Lock思路Tag 打开转盘锁 Open the Lock 有一个带4个圆形转轮的转盘锁，每个转轮有10个数字 0-9，转轮可以自由转。每次旋转只能转一个转轮的一个数字。 初始数字为0000，一个代表4个转轮数字的字符串。 列表deadends标识了一组死亡数字，一旦转轮转到了这个列表中的任何数字，锁就无法再次转动，被永久锁定。 字符串target代表可以解锁的数字，求解锁需要的最小旋转次数，否则返回-1. deadends = ["0201","0101","0102
打开转盘锁
IT之一小佬的博客
04-30 577
你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' 。每个拨轮可以自由旋转：例如把 '9' 变为'0'，'0' 变为 '9' 。每次旋转都只能旋转一个拨轮的一位数字。 锁的初始数字为 '0000' ，一个代表四个拨轮的数字的字符串。 列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无法再被旋...
Leetcode.752打开转盘锁C++
sakeww的博客
02-15 328
链接： https://leetcode-cn.com/problems/open-the-lock/ 描述： 示例： 代码： class Solution { public: int openLock(vector<string>& deadends, string target) { //哈希表用于查询 unordered_set<string> deadendsSet(deadends.begin(),deadends.en
33.打开转盘锁
Quiet_han的博客
07-01 247
文章目录一、题目描述二、解题思路三、代码演示 一、题目描述 你有一个带有四个圆形拨轮的转盘锁。每个拨轮都有10个数字： ‘0’, ‘1’, ‘2’, ‘3’, ‘4’, ‘5’, ‘6’, ‘7’, ‘8’, ‘9’ 。每个拨轮可以自由旋转：例如把 ‘9’ 变为 ‘0’，‘0’ 变为 ‘9’ 。每次旋转都只能旋转一个拨轮的一位数字。 锁的初始数字为 ‘0000’ ，一个代表四个拨轮的数字的字符串。 列表 deadends 包含了一组死亡数字，一旦拨轮的数字和列表里的任何一个元素相同，这个锁将会被永久锁定，无
【广度优先+模拟循环】752. 打开转盘锁
LogosTR_的博客
07-03 611
广度优先，模拟循环
Python刷题: LeetCode数据结构与算法分类练习
资源摘要信息:"LeetCode分类-algo_demo:数据结构与算法练习" LeetCode是一个国际知名的在线编程平台，它为程序员提供了一个通过解决实际问题来提升编程技能的环境。在这个平台上，用户可以找到各种难度的算法题目，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值