ZOJ - 2477 Magic Cube 【迭代加深+模拟】

Y390d Y390d 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 400+累计阅读 443平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-03-22 00:27:14 发布 443 阅读 AI 写同款· GEO 优化 ›
ZOJ 2477 Magic Cube 三阶魔方还原（IDA*） 转载请注明出处，谢谢 http://blog.youkuaiyun.com/ACM_cxlove?viewmode=contents           by---cxlove 三阶魔方还原。因为只搜5层，所以使用IDA*搜索。由于每次旋转，每面中心颜色总不变，也就确定了最终的状态，找出每个面中与中间颜色不同的个数的最大值，其中每次旋转会更改每个面的3个位置的颜色，所以 就是（最大值+2）/3。 总共 阅读详情

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2477

从接触acm到现在，一直很抵触ZOJ的题目，我做过的很多ZOJ的题目大部分题意都很模糊，阐述不清楚。

这道题的难点不在搜索，光看题目的问法都应该知道是用迭代加深，但是真正让人崩溃的是什么地方？

首先是立方的展开图，如果没指名哪一面是正面或者背面，对应的顺逆时针方向也会不同，题目没说明怎么办？能咋办，我只有去试啊，我最先是以索引为1的这一面为立方的背面，然后模拟顺逆时针的旋转，一直WA，而且还不敢肯定WA的原因是顺逆时针还是其他地方没写好，当我以索引为1的这一面为正面的时候，重新修改模拟顺逆时针的代码，就AC了。真的无话可说。

 

#include <iostream>
#include <queue>
#include <cstring>
#include <string>
#include <map>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;
const int Maxn = 4e5+10;

int cube[10][4][4];

bool check() {
    for(int i = 0; i < 6; ++i) {
        int tmp = cube[i][0][0];
        for(int j = 0; j < 3; ++j) {
            for(int k = 0; k < 3; ++k) if(tmp != cube[i][j][k]) {
                return false;
            }
        }
    }
    return true;
}

void Size(int x, int dir) {
    if(dir == 1) {
        swap(cube[x][0][0], cube[x][0][2]);
        swap(cube[x][0][0], cube[x][2][2]);
        swap(cube[x][0][0], cube[x][2][0]);
        swap(cube[x][0][1], cube[x][1][2]);
        swap(cube[x][0][1], cube[x][2][1]);
        swap(cube[x][0][1], cube[x][1][0]);
    } else {
        swap(cube[x][0][0], cube[x][2][0]);
        swap(cube[x][0][0], cube[x][2][2]);
        swap(cube[x][0][0], cube[x][0][2]);
        swap(cube[x][0][1], cube[x][1][0]);
        swap(cube[x][0][1], cube[x][2][1]);
        swap(cube[x][0][1], cube[x][1][2]);
    }
}

void solve(int x, int dir) {
    Size(x, dir);
    if(x == 1 && dir == 1) { //
        swap(cube[4][2][0], cube[2][0][0]); swap(cube[4][2][2], cube[2][2][0]);
        swap(cube[4][2][0], cube[5][0][2]); swap(cube[4][2][2], cube[5][0][0]);
        swap(cube[4][2][0], cube[0][2][2]); swap(cube[4][2][2], cube[0][0][2]);
        swap(cube[4][2][1], cube[2][1][0]);
        swap(cube[4][2][1], cube[5][0][1]);
        swap(cube[4][2][1], cube[0][1][2]);
    } else if(x == 1 && dir == -1) {
        swap(cube[4][2][0], cube[0][2][2]); swap(cube[4][2][2], cube[0][0][2]);
        swap(cube[4][2][0], cube[5][0][2]); swap(cube[4][2][2], cube[5][0][0]);
        swap(cube[4][2][0], cube[2][0][0]); swap(cube[4][2][2], cube[2][2][0]);
        swap(cube[4][2][1], cube[0][1][2]);
        swap(cube[4][2][1], cube[5][0][1]);
        swap(cube[4][2][1], cube[2][1][0]);
    }

    if(x == 3 && dir == -1) { //
        swap(cube[4][0][0], cube[2][0][2]); swap(cube[4][0][2], cube[2][2][2]);
        swap(cube[4][0][0], cube[5][2][2]); swap(cube[4][0][2], cube[5][2][0]);
        swap(cube[4][0][0], cube[0][2][0]); swap(cube[4][0][2], cube[0][0][0]);
        swap(cube[4][0][1], cube[2][1][2]);
        swap(cube[4][0][1], cube[5][2][1]);
        swap(cube[4][0][1], cube[0][1][0]);
    } else if(x == 3 && dir == 1) {
        swap(cube[4][0][0], cube[0][2][0]); swap(cube[4][0][2], cube[0][0][0]);
        swap(cube[4][0][0], cube[5][2][2]); swap(cube[4][0][2], cube[5][2][0]);
        swap(cube[4][0][0], cube[2][0][2]); swap(cube[4][0][2], cube[2][2][2]);
        swap(cube[4][0][1], cube[0][1][0]);
        swap(cube[4][0][1], cube[5][2][1]);
        swap(cube[4][0][1], cube[2][1][2]);
    }

    if(x == 2 && dir == -1) { //
        swap(cube[3][0][0], cube[4][2][2]); swap(cube[3][2][0], cube[4][0][2]);
        swap(cube[3][0][0], cube[1][2][2]); swap(cube[3][2][0], cube[1][0][2]);
        swap(cube[3][0][0], cube[5][2][2]); swap(cube[3][2][0], cube[5][0][2]);
        swap(cube[3][1][0], cube[4][1][2]);
        swap(cube[3][1][0], cube[1][1][2]);
        swap(cube[3][1][0], cube[5][1][2]);
    } else if(x == 2 && dir == 1) {
        swap(cube[3][0][0], cube[5][2][2]); swap(cube[3][2][0], cube[5][0][2]);
        swap(cube[3][0][0], cube[1][2][2]); swap(cube[3][2][0], cube[1][0][2]);
        swap(cube[3][0][0], cube[4][2][2]); swap(cube[3][2][0], cube[4][0][2]);
        swap(cube[3][1][0], cube[5][1][2]);
        swap(cube[3][1][0], cube[1][1][2]);
        swap(cube[3][1][0], cube[4][1][2]);
    }

    if(x == 0 && dir == 1) { //
        swap(cube[3][0][2], cube[4][2][0]); swap(cube[3][2][2], cube[4][0][0]);
        swap(cube[3][0][2], cube[1][2][0]); swap(cube[3][2][2], cube[1][0][0]);
        swap(cube[3][0][2], cube[5][2][0]); swap(cube[3][2][2], cube[5][0][0]);
        swap(cube[3][1][2], cube[4][1][0]);
        swap(cube[3][1][2], cube[1][1][0]);
        swap(cube[3][1][2], cube[5][1][0]);
    } else if(x == 0 && dir == -1) {
        swap(cube[3][0][2], cube[5][2][0]); swap(cube[3][2][2], cube[5][0][0]);
        swap(cube[3][0][2], cube[1][2][0]); swap(cube[3][2][2], cube[1][0][0]);
        swap(cube[3][0][2], cube[4][2][0]); swap(cube[3][2][2], cube[4][0][0]);
        swap(cube[3][1][2], cube[5][1][0]);
        swap(cube[3][1][2], cube[1][1][0]);
        swap(cube[3][1][2], cube[4][1][0]);
    }

    if(x == 5 && dir == -1) { //
        swap(cube[3][2][0], cube[2][2][0]); swap(cube[3][2][2], cube[2][2][2]);
        swap(cube[3][2][0], cube[1][2][0]); swap(cube[3][2][2], cube[1][2][2]);
        swap(cube[3][2][0], cube[0][2][0]); swap(cube[3][2][2], cube[0][2][2]);
        swap(cube[3][2][1], cube[2][2][1]);
        swap(cube[3][2][1], cube[1][2][1]);
        swap(cube[3][2][1], cube[0][2][1]);
    } else if(x == 5 && dir == 1) {
        swap(cube[3][2][0], cube[0][2][0]); swap(cube[3][2][2], cube[0][2][2]);
        swap(cube[3][2][0], cube[1][2][0]); swap(cube[3][2][2], cube[1][2][2]);
        swap(cube[3][2][0], cube[2][2][0]); swap(cube[3][2][2], cube[2][2][2]);
        swap(cube[3][2][1], cube[0][2][1]);
        swap(cube[3][2][1], cube[1][2][1]);
        swap(cube[3][2][1], cube[2][2][1]);
    }

    if(x == 4 && dir == -1) { //
        swap(cube[0][0][0], cube[1][0][0]); swap(cube[0][0][2], cube[1][0][2]);
        swap(cube[0][0][0], cube[2][0][0]); swap(cube[0][0][2], cube[2][0][2]);
        swap(cube[0][0][0], cube[3][0][0]); swap(cube[0][0][2], cube[3][0][2]);
        swap(cube[0][0][1], cube[1][0][1]);
        swap(cube[0][0][1], cube[2][0][1]);
        swap(cube[0][0][1], cube[3][0][1]);
    } else if(x == 4 && dir == 1) {
        swap(cube[0][0][0], cube[3][0][0]); swap(cube[0][0][2], cube[3][0][2]);
        swap(cube[0][0][0], cube[2][0][0]); swap(cube[0][0][2], cube[2][0][2]);
        swap(cube[0][0][0], cube[1][0][0]); swap(cube[0][0][2], cube[1][0][2]);
        swap(cube[0][0][1], cube[3][0][1]);
        swap(cube[0][0][1], cube[2][0][1]);
        swap(cube[0][0][1], cube[1][0][1]);
    }
}

int ans[10][2], cnt;

void print() {
    for(int i = 0; i < 6; ++i) {
        for(int j = 0; j < 3; ++j) {
            for(int k = 0; k < 3; ++k) cout << cube[i][j][k] << " ";
            cout << endl;
        }
        cout << endl;
    }
}

bool dfs(int dep, int step) {
    if(check()) return true;
    if(step == dep) return false;

    for(int i = 0; i < 6; ++i) {
        ans[cnt][0] = i; ans[cnt][1] = -1;
        cnt++; solve(i, -1);
        if(dfs(dep, step+1)) return true;
        cnt--; solve(i, 1);

        ans[cnt][0] = i; ans[cnt][1] = 1;
        cnt++; solve(i, 1);
        if(dfs(dep, step+1)) return true;
        cnt--; solve(i, -1);
    }
    return false;
}

int main(void)
{
    int T;
    scanf("%d", &T);
    while(T--) {
        int r = 0, c = 0;
        while(r < 2 || c < 3) {
            char ch = getchar();
            if(c == 3) {
                c = 0; r++;
            }
            if(ch >= 'a' && ch <= 'z') cube[4][r][c++] = ch-'a';
        }
        r = 0; c = 0;
        while(r < 2 || c < 12) {
            char ch = getchar();
            if(c == 12) {
                c = 0; r++;
            }
            if(ch < 'a' || ch > 'z') continue;
            if(c < 3) cube[0][r][c] = ch-'a';
            else if(c < 6) cube[1][r][c-3] = ch-'a';
            else if(c < 9) cube[2][r][c-6] = ch-'a';
            else cube[3][r][c-9] = ch-'a';
            c++;
        }
        r = 0; c = 0;
        while(r < 2 || c < 3) {
            char ch = getchar();
            if(c == 3) {
                c = 0; r++;
            }
            if(ch >= 'a' && ch <= 'z') cube[5][r][c++] = ch-'a';
        }
      //  print();
        cnt = 0; bool ok = false;

        for(int dep = 1; dep <= 5; ++dep) {
            if(dfs(dep, 0)) {
                ok = true; break;
            }
        }
        if(!ok) printf("-1\n");
        else {
            printf("%d\n", cnt);
            for(int i = 0; i < cnt; ++i) printf("%d %d\n", ans[i][0], ans[i][1]);
        }
    }
	return 0;
}

 

收录于
DFS

当前文章被收录于：

DFS
12 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
科研绘图避坑指南：用PyMol制作期刊级蛋白-配体相互作用图（含氢键显示技巧） 本文是一份专业的科研绘图避坑指南，详细讲解如何利用PyMol软件制作符合期刊发表标准的蛋白-配体相互作用图。文章重点分享了从构图逻辑、精准选择到氢键等相互作用的艺术化表达技巧，并提供了视觉优化与期刊适配的终极参数设置，帮助科研人员产出兼具科学严谨性与视觉美感的专业图表。 阅读详情

相关推荐

管理信息系统（MIS）设计

一名读者可以借阅多本图书,而一本图书也可以被不同的读者借阅,所以读者与图书之间存在着多对多的借阅关系，读者与图书之间存在着多对多的联系,即m:n的联系。每一种图书属于一种图书类型,而一种图书类型可以包含很多本图书,因此可以得到图书类型与图书之间也存在着一种一对多的联系,即图书类型与图书是1:n的联系。系统应该实现以下功能:图书管理员可以维护图书信息，包括增加新书、修改图书信息、办理图书借阅登记、图书归还登记、过期图书处理、丢失图书处理及读者借阅证件信息的维护等;

m0_69718745的博客 2476

Magic Cube ZOJ - 2477

Magic Cube ZOJ - 2477 s输入的是打开立方体，目的是转到每一面都只有一个颜色。 输入：输入t，表示t组数据，每组数据有10行，第一行为空然后九行的格式为： w w w w w w w w w（4） r r r g g g b b b o o o r r r g g g b b b o o o r r r g g g b b ...

DeathYmz的博客 651

手把手教你用Wireshark国密版分析TLCP和IPSec协议（附下载地址）

本文详细介绍了Wireshark国密版在TLCP和IPSec协议分析中的实战应用，包括环境配置、协议解析、合规性检查及高级分析技巧。该工具针对商用密码算法（如SM2/SM3/SM4）进行了专项优化，支持GB/T 38636-2020 TLCP和GB/T 36968-2018 IPSec VPN等国家标准，帮助开发者与安全工程师高效完成密评分析任务。

weixin_29325955的博客 553

ZOJ-2477 Magic Cube

题目： http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2477 题意： 三阶魔方复原。 思路： 最多5步，所以暴力搜索就行了，主要是状态的记录和选装状态怎么写。然后IDA*慢慢深搜即可。 代码： int n,m; int flag,sum,res[10]; int row[6][8]={ {0,1,2

MyWorld 1225

1.2 从“跟网”到“构网”：技术范式的历史性转变

新型电力系统面临"双高"特征带来的稳定性挑战，促使并网控制技术从"跟网型"向"构网型"范式转变。传统跟网型变流器作为受控电流源依赖强电网，存在短路电流能力有限、易失稳等缺陷；而构网型变流器模拟同步发电机特性，作为受控电压源具备自主建立电压/频率、提供虚拟惯性、增强短路容量和改善系统阻尼四大核心能力。这一技术范式转变使变流器从电网跟随者变为构建支撑者，成为解决新能源大规模接入稳定性的关键。

技术工作者 722

OneNet新版MQTT+OneJSON接入全指南

物联网云平台设备接入是嵌入式系统与云端协同的基础能力，其核心依赖于标准化通信协议与统一数据模型。MQTT作为轻量级发布/订阅协议，凭借低带宽占用和高可靠性，成为边缘设备上云的主流选择；而物模型（Thing Model）则定义了设备能力的数字契约，支撑数据语义化与平台自治管理。OneNet新版强制采用MQTT+OneJSON协议栈，不仅提升数据解析一致性与安全认证强度，更推动开发范式从‘协议适配’转向‘模型驱动’。该架构广泛适用于环境监测、智能表计、工业传感等场景，尤其利好基于ESP8266、STM32等资源

weixin_42599558的博客 361

ZOJ - 2477 dfs [kuangbin带你飞]专题二

注意输入的处理，旋转操作打表。递增枚举可能步数，作为限制方便找到最短路。 AC代码：90ms #include<cstdio> #include<cstring> char magic[60]; int cube[6][9] = { {4,0,1,2,3,5,6,7,8},{22,9,10,11,21,23,33,34,35},{25,12,13,14...

weixin_30340617的博客 191

【2024保研经验帖】中科院信工所夏令营经验分享

中科院信工所夏令营经验分享，信工所夏令营据说只要报了就能进，这个是不是真的尚不清楚，不过qq群里有八九百个人，也属实可怕。招生老师说我们这届夏令营招200-300个左右，于是又开始惶惶不安。 夏令营时期都是线上进行，先是每个科室进行线上招生宣讲，然后报名第一志愿部门和第二志愿部门，不同部门的考核是不同的。有的部门只要求英语面试和综合面试，有的部门除了面试还需要机试，而有的部门除了这些还需要笔试。

m0_63002183的博客 4489

ZOJ2477 IDA*搜索进阶

问题大意就是给你一个魔方，让你在五步之内还原这个魔方，这个魔方只能让每个面进行顺时针或者逆时针操作，问能否在五步内解决战斗，如果可以，请输出每一步转动的面，以及是逆时针还是顺时针。 分析：对于这个问题，核心在于如何魔方的转动，以及预估函数的判断；  关于预估函数，我的观点是当你想出正确的模拟转动过程后这个预估函数也就很好写了，所以先对魔方转动模拟的分析：首先可以知道每转动一次都会有20个方块改变...

HPU WIN 403

Ubuntu22.04+Docker一键部署Autoware Universe避坑指南（附鱼香ROS配置）

本文详细介绍了在Ubuntu22.04系统中使用Docker一键部署Autoware Universe的完整流程，包括鱼香ROS工具链配置、Docker环境优化及VSCode开发环境集成。通过实战指南帮助开发者快速搭建自动驾驶开发环境，解决常见部署问题，提升开发效率。

weixin_29254673的博客 414

WordPress插件depicter存在SQL注入漏洞(CVE-2025-2011)

Depicter 是一款功能强大的 WordPress 幻灯片插件，允许用户通过直观的拖放编辑器轻松创建响应式滑块、轮播和动态内容展示。该插件提供丰富的模板库、动画效果和图层控制，支持多媒体内容嵌入（如图片、视频、HTML），并优化了移动端显示和SEO性能。其无代码操作界面适合非技术用户，同时提供高级自定义选项，适用于产品展示、营销推广和视觉叙事等多种场景，是提升网站视觉吸引力的高效工具。

m0_50125527的博客 551

ZOJ 2477Magic Cube(打表模拟)

感觉这道题真的是很好的一道题，我比较认可这个方法就是按照读入顺序来对颜色块，进行编码然后预先打表处理出每个面顺逆时针旋转之后的位置，认真一点把表打对，然后可以利用迭代加深搜索出最小的步数。 #include <bits/stdc++.h> using namespace std; char readchar() { char ch = 0; while (!isalp...

Bran 410

本地Pycharm连接远程服务器详细配置过程（直接在本地使用服务器显卡，很棒）

相信很多人都遇见过这种情况：实验室成员使用同一台服务器，每个人拥有自己的独立账号，我们可以使用服务器更好的配置完成实验，毕竟自己哪有money拥有自己的3090呢。

NorthSmile的博客 4万+

Magic Cube

传送门ZOJ2477描述 This is a very popular game for children. In this game, there’s a cube, which consists of 3 3 3 small cubes. We can unwrap the cube, it will become like ...

umalaka的博客 1314

IEM模型，地表粗糙度模拟

利用微波反演土壤水分时候，利用IEM模型可以实现对随机地表的模拟

VC中sqlite的使用

在VC中对sqlite的使用，实现数据库大批数据的快速插入，读取数据库中的数据在ListCtrl中显示

ZOJ Magic Cube 2477

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2477 最大深度只有5层， 用IDA* 算法, 这题的亮点就是用数组来预处理模方的每种旋转，节约时间和代码量 。 h函数的选择： 因为无论怎么旋转，每块魔方的中间位置的颜色是不会变的，因此可以用总共不在原来面上的方块数来作为h函数。 每次旋转，最多能使12块魔方回到原来的

Chris_Home 1409

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能：商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传，基本资料下载，开钱箱、小票打印、收款结算，支持多币种付款方式（现金、储值卡、礼券、微信等）,支持多种促销。运行环境：.net 4.0登陆信息用户名:1001 密码:123456内置商品信息，商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

ZOJ 2477 Magic Cube

This is a very popular game for children. In this game, there’s a cube, which consists of 3 * 3 * 3 small cubes. We can unwrap the cube, it will become like this w w w w w w w w w r r r...

qq_43735840的博客 299

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术，以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索，主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式，计算机控制系统的数学描述与基本分析方法，以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

ZOJ 2477 Magic Cube (IDA*)

题面 This is a very popular game for children. In this game, there's a cube, which consists of 3 * 3 * 3 small cubes. We can unwrap the cube, it will become like this: w w w w w w w ...

Yi_Qing_Z的博客 650

ZOJ2477 Magic Cube

题目： This is a very popular game for children. In this game, there's a cube, which consists of 3 * 3 * 3 small cubes. We can unwrap the cube, it will become like this: w w ww w w...

weixin_30740295的博客 120

ZOJ - 2477 Magic Cube 题解

This is a very popular game for children. In this game, there's a cube, which consists of 3 * 3 * 3 small cubes. We can unwrap the cube, it will become like this: w w ww w ww w...

aiba481424的专栏 158

Magic Cube ZOJ - 2477 IDA*模拟

棘手的模拟， 要算出移动后的位置， 注意顺逆针方向， wa了几次， 用IDA*搜索 因为中心颜色确定，找出每个面与中心颜色不同的数量， 每次旋转最多改变12个， 当不同数量／12>深度时剪枝。#include <iostream> #include <cstdio> #include <algorithm> #include <vector> #include <cstring> #include

WsMiracle的博客 534

[kuangbin]专题二 搜索进阶 Magic Cube ZOJ - 2477【BFS】

【题目描述】 This is a very popular game for children. In this game, there’s a cube, which consists of 3 * 3 * 3 small cubes. We can unwrap the cube, it will become like this: w w w w w w w w w r r r g g g ...

inv0ker的博客 181

zoj2477 Magic Cube (bfs)

题意是给一个3阶魔方输出复原的步骤。如果步数大于5就输出-1。 这道题有IDA*的做法……但是蒟蒻只会bfs…… 200行代码简直就像一坨*。 完整代码（我都不好意思贴出来）： #include #include #include #include #include using namespace std; struct Node { char cube[6][3]

Shion的专栏 671
上一篇： HDU - 1560 DNA sequence 【迭代加深】
下一篇： HDU - 1067 Gap 【BFS+字符串压缩状态】
点赞 0
评论 0
书签 书签 0
Y390d
Y390d
博客等级 码龄9年 11粉丝 165原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值