DLX解 各种规模数独

最新推荐文章于 2020-10-29 00:27:00 发布
最新推荐文章于 2020-10-29 00:27:00 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数独 文章标签： allocation stream 存储 c email 算法

QQ;1423173783   email:1423173783@qq.com

// 本代码用DLX算法解决K*K*K*K数独，特点是覆盖了前K*K*K*K列，战斗就解决了，把战斗浓缩在前K*K*K*K列。缺点是用了new 调试不方便，new的数组不好观测
//解题填空顺序存储在O[]中      舞池本来应该用双向十字链表做材料，本代码用二维数组模拟
//本代码虽然可以做规模不同的数独（自然包括9*9），但随着K的变大U,D,R,L数组大小要变，(K*K*K*K*3+1)*3+1是几位数 new中前面的100000就要改为10的几次方
//事实上，K=5就做不了，会有abort错误，堆allocation出错
#include<iostream>
#include<cstdlib>
#include<time.h>
#include<fstream>
using namespace std;
#define K  4
fstream  out_stream;
int node[K*K+1][K*K+1];
long time1,time2;
int O[K*K*K*K+1],S[K*K*K*K+1],a[K*K*K*K*K*K+1][K*K*K*K*3+1],O_sub=1;// O[]依次存储覆盖每一列用的行号，行号隐藏了哪一个格子填了哪一个候选数
int *U=new int[(K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1];              //S[82]存放前81列的候选数可能数，对应于每个格子的候选数
int *D=new int[(K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1];              //a[][]用来表示跳舞的舞池  U[]  D[]  R[]   L[]  是舞池的设置
int *R=new int[(K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1];
int *L=new int[(K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1];
void remove(int c);         //用来覆盖列
void resume(int c);         //用来恢复列  
bool DFS(int k);            //每次优先覆盖候选数可能数最少的列
int room(int row,int col);   // 给定行号，列号，求宫号
void init(int start[K*K*K*K+1]);    //预先处理：布置公共舞池，对于特定的舞会（特定的数独题）还要事先做些准备工作
void print_all();            //把结果输出到相应的文件，即每个格子填什么数
void subtraction(int pos,int k); //减候选数 并取消某一格子对应的某一候选数 所对应的行的覆盖资格
void add(int pos,int k);         //与上一函数相反
int row_room(int rom);            //给定宫号，求宫的开始行号
int col_room(int rom);          //给定宫号，求宫的开始列号
void remove(int c)
{
 L[R[c]]=L[c];
 R[L[c]]=R[c];
 for(int i=D[c];i!=c;i=D[i])
  for(int j=R[i];j!=i;j=R[j])
  {
   if(j%10000==0) continue;
   U[D[j]]=U[j];
   D[U[j]]=D[j];
   //S[j%1000]--;    这里保留原来的痕迹     后来改动的原因是，减候选数只会会减前81列，原来不光subtraction会减remove也会减，remove不会减前81列候选数，这里删掉耗时肯定变少，S[244]-->S[82]空间消耗也变少，别小看耗时少了5ms
  }
}
void resume(int c)
{
 for(int i=U[c];i!=c;i=U[i])
  for(int j=L[i];j!=i;j=L[j])
  {  
   if(j%10000==0) continue;
   U[D[j]]=j;
   D[U[j]]=j;
   //S[j%1000]++;
  }
    L[R[c]]=c;
 R[L[c]]=c;
}
bool DFS(int k)
{
 if(!R[0])  return(true);
 int count=100,c;
 for(int i=R[0];i<=K*K*K*K;i=R[i])//i改为i<=81
  if(S[i]<count)
  {
   count=S[i];
   c=i;
   if(count==1) break;
  }
    remove(c);
  for(int i=D[c];i!=c;i=D[i])
 {
  if(L[i]%10000==0)
  {
     int pos=(i/10000-1)/(K*K)+1,k1;//1<=pos<=81
     k1=i/10000-K*K*(pos-1);
     O[k]=i/10000;
     subtraction(pos,k1);
     for(int j=R[i];j%10000>0 && j%10000<K*K*K*K*3+1;j=R[j])//j!=i改为j!=0 && j!=1又改为j>1000  又改为j!=1000 && j!=2000
     remove(j%10000);
     if(DFS(k+1)) return (true);
     for( int j=L[L[i]];j!=i;j=L[j])  
     resume(j%10000);
     add(pos,k1);
  }
 }
 resume(c);
 return(false);
}
int room(int row,int col)
{
 return((row-1)/K*K+1+(col-1)/K);
}

void init(int start[K*K*K*K+1])
{
    int row,col;
 memset(U,0,((K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1)*4);
 memset(D,0,((K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1)*4);
 memset(R,0,((K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1)*4);
 memset(L,0,((K*K*K*K*K*K+1)*10000+(K*K*K*K*3+1)*3+1)*4);
 for(col=0;col<=K*K*K*K*3;col++)
 {
  L[col]=col-1;
  R[col]=col+1;
 }
 L[0]=K*K*K*K*3;   R[K*K*K*K*3]=0;
 for(int i=1;i<=K*K*K*K;i++)
  S[i]=K*K;
 for( row=1;row<=K*K*K*K*K*K;row++)
 {
  int k=(row-1)/(K*K)+1;
  int row1=(k-1)/(K*K)+1,col1=(k%(K*K)==0)?K*K:(k%(K*K));
  int acol1,acol2,acol3;
     acol1=K*K*(row1-1)+col1;
  acol2=K*K*(K*K+col1-1)+row1;
  acol3=K*K*(K*K*2+room(row1,col1)-1)+(row1-(room(row1,col1)-1)/K*K-1)*K+col1-(room(row1,col1)-1)%K*K;
  a[row][acol1]=1;  a[row][acol2]=1;  a[row][acol3]=1; 
 }
    for(col=1;col<=K*K*K*K*3;col++)
 {
  int tmp;
  row=1;
  while(a[row][col]==0)
  { row++; } ;
  tmp=row; ;
  D[col]=10000*row+col;
  U[10000*row+col]=col;
  for(int i=row+1;i<=row+K*K-1;i++)//i<=729改为row+8  实验证明耗时降了1ms
   if(a[i][col]==0) continue;
   else
   {
    D[10000*tmp+col]=10000*i+col;
    U[10000*i+col]=10000*tmp+col;
    tmp=i;
      }
        D[10000*tmp+col]=col;
  U[col]=10000*tmp+col;
 }
 for(row=1;row<=K*K*K*K*K*K;row+=K*K)   //for循环内的内容经过替换  耗时减少大概0.5ms  不小心把原来for循环中的内容删掉了
 {
  int row0,col0,rom0,col1,col2,col3;
  col1=(row-1)/(K*K)+1;
  row0=(col1-1)/(K*K)+1;
  col0=col1-K*K*(row0-1);
  rom0=room(row0,col0);
  col2=K*K*(K*K+col0-1)+row0;
  col3=K*K*(K*K*2+rom0-1)+(row0-row_room(rom0))*K+(col0-col_room(rom0)+1);
  for(int i=row;i<=row+K*K-1;i++)
  {
   R[i*10000]=i*10000+col1;        L[i*10000+col1]=i*10000;
   R[i*10000+col1]=i*10000+col2;   L[i*10000+col2]=i*10000+col1;
   R[i*10000+col2]=i*10000+col3;   L[i*10000+col3]=i*10000+col2;
   R[i*10000+col3]=i*10000;        L[i*10000]=i*10000+col3;
  }
 }
 for(int i=1;i<=K*K*K*K;i++)
  if(start[i]!=0)
  {
            int row1=(i-1)/(K*K)+1,col1=(i%(K*K)==0)?K*K:(i%(K*K));
   int acol1,acol2,acol3;
   acol1=K*K*(row1-1)+col1;
   acol2=K*K*(K*K+col1-1)+row1;
   acol3=K*K*(K*K*2+room(row1,col1)-1)+(row1-(room(row1,col1)-1)/K*K-1)*K+col1-(room(row1,col1)-1)%K*K;
   O[O_sub++]=K*K*(i-1)+start[i];
   subtraction(i,start[i]);//原来是放在三个remove后  DFS中也要做相应调整
   remove(acol1);
   remove(acol2); 
   remove(acol3);
  }
}
void print_all()
{ 
 out_stream<<"print storage"<<endl;
   for(int i=1;i<=K*K;i++)
     {
    for(int j=1;j<=K*K;j++)
     {
   out_stream<<node[i][j]<<" ";
     if(j%K==0) out_stream<<"   ";
     }   
    out_stream<<endl;
    if(i%K==0)  out_stream<<endl;
     }
   out_stream<<endl<<endl;
}
void subtraction(int pos,int k)
{
     int row=(pos-1)/(K*K)+1,col=(pos%(K*K)==0)? K*K:(pos%(K*K));
     int rom=room(row,col),scol1,scol2,scol3;
     scol1=K*K*(row-1)+1;  scol2=K*K*(K*K+col-1)+1;  scol3=K*K*(K*K*2+rom-1)+1;
     for(int j=scol1;j<=scol1+K*K-1;j++)
     {
      int m=D[j];//后来加的，发现j按原来代码j一下子变得很大，就出了循环 ，改过后for循环的代码看起来也更易理解
      if(D[j]==j)  continue;  //这一列以前被remove掉，不该处理的不处理，该处理的一定处理
      S[j]--;
      while(L[m]/10000-(L[m]/10000-1)/(K*K)*K*K!=k)  m=D[m];
      L[m]+=(K*K*K*K*3+1);R[L[m]]=m;L[L[m]]=R[R[m]];   R[R[R[m]]]=L[m];
     }
     for(int j=scol2;j<=scol2+K*K-1;j++)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(L[L[m]]/10000-(L[L[m]]/10000-1)/(K*K)*K*K!=k) 
       m=D[m];
      if(L[m]%10000!=K*K*row-1+col)  S[L[m]%10000]--;
      L[L[m]]+=(K*K*K*K*3+1);R[L[L[m]]]=L[m];L[L[L[m]]]=R[m];   R[R[m]]=L[L[m]];
     }
     for(int j=scol3;j<=scol3+K*K-1;j++)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(R[m]/10000-(R[m]/10000-1)/(K*K)*K*K!=k)  m=D[m];
      if(((L[L[m]]/10000-1)/(K*K))/(K*K)+1!=row  && L[L[m]]%10000-(L[L[m]]%10000-1)/(K*K)*K*K!=col) S[L[L[m]]%10000]--;//if(((L[L[m]]/1000-1)/9)/9+1!=row)改为if(((L[L[m]]/1000-1)/9)/9+1!=row && L[L[m]]%1000-(L[L[m]]%1000-1)/9*9!=col)
      R[m]+=(K*K*K*K*3+1);L[R[m]]=m;R[R[m]]=L[L[m]];   L[L[L[m]]]=R[m];                                       //这样改使得同一个候选数不会使某个格子的probable值减两次，如果减两次下次选择覆盖列就不是最优化，我预测这样改会降低时间复杂度。
     }                                                                                                 //实际上耗时反而增加了，改前1674ms  改后3636ms  我还是觉得随着数独规模的增大比如16*16,25*25数独，改后的代码时间复杂度会更好        
}                                                                                                            // 我做了16*16  代码中的选择速度要慢，可能规模还是不大没体现它的优势，可是16*16已经把内存几乎都用光了          
void add(int pos,int k)                                                                                                      
{
       int row=(pos-1)/(K*K)+1,col=(pos%(K*K)==0)? K*K:(pos%(K*K));
     int rom=room(row,col),scol1,scol2,scol3;
     scol1=K*K*(row-1)+1;  scol2=K*K*(K*K+col-1)+1;  scol3=K*K*(K*K*2+rom-1)+1;
     for(int j=scol3+K*K-1;j>=scol3;j--)
     {
      int m=D[j];
      if(D[j]==j)  continue;//不该恢复的不恢复，该恢复的一定恢复，不管处理了几次恢复到原样
      while(R[m]/10000-(R[m]/10000-1)/(K*K)*K*K!=k)  m=D[m];
      R[m]-=(K*K*K*K*3+1);L[R[m]]=m;R[R[m]]=L[L[m]];   L[L[L[m]]]=R[m];
      if(((L[L[m]]/10000-1)/(K*K))/(K*K)+1!=row  && L[L[m]]%10000-(L[L[m]]%10000-1)/(K*K)*K*K!=col) S[L[L[m]]%10000]++;
     }
     for(int j=scol2+K*K-1;j>=scol2;j--)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(L[L[m]]/10000-(L[L[m]]/10000-1)/(K*K)*K*K!=k)  m=D[m];
      L[L[m]]-=(K*K*K*K*3+1);R[L[L[m]]]=L[m];L[L[L[m]]]=R[m];   R[R[m]]=L[L[m]];
      if(L[m]%10000!=K*K*row-1+col)  S[L[m]%10000]++;
     }
      for(int j=scol1+K*K-1;j>=scol1;j--)
     {
      int m=D[j];
      if(D[j]==j)  continue;
      while(L[m]/10000-(L[m]/10000-1)/(K*K)*K*K!=k)  m=D[m];
      L[m]-=(K*K*K*K*3+1);R[L[m]]=m;L[L[m]]=R[R[m]];   R[R[R[m]]]=L[m];
      S[j]++;
     }
}
int row_room(int rom)
{
    return((rom-1)/K*K+1);
}
int col_room(int rom)
{
 return((rom-1)%K*K+1);
}
int main()
{
 int int_start[K*K*K*K+1];   //开始用于存储从文件中读取的题目，后来用来存储解题结果
 ifstream cin_stream;
 cin_stream.open("d:\\c++\\数独12\\question\\4.txt");
 for(int i=1;i<K*K*K*K+1;i++)
  cin_stream>>int_start[i];
 out_stream.open("d:\\c++\\数独12\\question\\question474.txt");
 time1=clock();
 init(int_start);
 DFS(O_sub);
 time2=clock();
 for(int i=1;i<=K*K*K*K;i++)
       int_start[(O[i]-1)/(K*K)+1]=O[i]-(O[i]-1)/(K*K)*K*K;
 for(int i=1;i<=K*K*K*K;i++)
 {
  int row,col;
  row=(i-1)/(K*K)+1;
  col=(i%(K*K)==0)?K*K:(i%(K*K));
  node[row][col]=int_start[i];
 }
 for(int i=1;i<=K*K*K*K;i++)
  out_stream<<((O[i]-1)/(K*K))/(K*K)+1<<"        "<<(O[i]-1)/(K*K)+1-((O[i]-1)/(K*K))/(K*K)*K*K<<"      "<<O[i]-(O[i]-1)/(K*K)*K*K<<endl;
 out_stream<<endl;
 out_stream<<O_sub-1<<endl;//输出的是初盘已经有的数的个数
 print_all();
 cout<<time2-time1<<"ms"<<endl;
 delete[] U;
 delete[] D;
 delete[] R;
 delete[] L;
 system("pause");
}

for_every_one
关注
专栏目录
DLX算法解数独游戏 Java版
魔神翼
07-11 2917
使用DLX算法解数独游戏。 初学Java，算法代码是由C代码转换的。 DLX.java是算法类，Sudoku.java是界面类。 解号称世界上最难的数独用时10ms以内。 算法详解 Sudoku 数独 Dancing Links模板 使用方法 int n = 9; DLX dlx = new DLX(n * n * n + 1, 4 * n * n);          
DLX解9*9数独 数组模拟双向十字链表
for_every_one的专栏
09-22 3476
QQ 1423173783   EMAIL:1423173783@qq,com  欢迎提出不同意见。 // 本代码用DLX算法解决9*9数独，特点是覆盖了前81列，战斗就解决了，把战斗浓缩在前81列。缺点是用了new 调试不方便，new的数组不好观测 //解题填空顺序存储在O[]中      舞池本来应该用双向十字链表做材料，本代码用二维数组模拟 #include #include #i
数独问题——DLX算法
a_forever_dream的博客
07-15 1038
如果还没有看过DLX算法请点这里~ 题目传送门 回想一下精确覆盖问题，它的要求是每一列恰好有一个1，那么我们可以考虑将每一列作为一个限制条件，那么将数独的限制条件套进去即可。 考虑数独的限制条件： 每一个空只能填一个数（这不是废话吗。。） 每一行中不能出现重复的数字，而且只能填1~9 每一列中不能出现重复的数字，而且只能填1~9 每一个宫中不能出现重复的数字，而且只能填1~9 这样看好像不是很...
DLX算法求解数独
BIT-1120161967的博客
04-16 2916
首先，DLX算法并不是为了解数独而提出的，它是为了解决精确覆盖问题而被提出的。精确覆盖问题：给定一个由0-1组成的矩阵，是否能找到一个行的集合，使得集合中每一列都恰好包含一个1。数独这个问题恰好拟合了DLX算法的模型，所以可以用该方法求解。DLX算法的具体分析请看跳跃的舞者，舞蹈链（Dancing Links）算法——求解精确覆盖问题。该帖讲述的十分详细，就不在这里赘述算法的本身了。DLX算法实质...
DLX 求解数独
阿豪
10-29 126
原文链接: DLX 求解数独 上一篇: ...
JavaFX和DLX算法实现的数独游戏.zip
05-26
JavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏.zipJavaFX和DLX算法实现的数独游戏....
基于JavaFX和DLX算法实现的数独游戏，可快速生成和解出数独.zip
05-13
数独游戏 上述方法称为基础解法（Basic Techniques），其他所有的解法称为进阶解法（Advanced Techniques），是在补基本解法之不足，所以又称辅助解法。 进阶解法包括：区块摒除法（Locked Candidates）、数组...
基于JavaFX和DLX算法的数独游戏设计源码
最新发布
10-03
该项目为JavaFX平台上的数独游戏，采用DLX算法进行快速生成和解题，包含21个文件，涵盖8个Java源文件、3个PNG图片、2个Markdown文档、1个Git忽略文件、1个Shell脚本、1个JSON配置文件、1个许可协议文件、1个JAR包、1...
dlx指令 DLX Instruction Set Architecture
04-09
DLX是一种32位精简指令集计算机（RISC）架构，其特点是可以仅用三种指令格式来管理。DLX的核心是一个固定的定点单元（FXU），并且它还包括一个浮点数扩展。DLX指令集架构主要由以下几个知识点组成： 1. DLX架构基础...
DLX.zip_DLX
09-22
总结起来，这个压缩包包含的资源是使用C++实现的DLX算法应用实例，主要针对各种需要高效搜索和覆盖问题求解的编程竞赛题目。通过分析和学习这些代码，我们可以深入理解DLX算法如何在实际问题中发挥作用，以及如何...
sudoku_solver:通过DLX解决数独
05-10
soduku_solver 通过DLX解决soduku。 建造 $ make 用法 用法： ./sudoku_sover [-v] [inputfile] 例子： $ ./sudoku_solver -v hardest_sudoku.txt input sudoku: +-------+-------+-------+ | 8 0 0 | 0 0 0 | 0 0 0 | | 0 0 3 | 6 0 0 | 0 0 0 | | 0 7 0 | 0 9 0 | 2 0 0 | +-------+-------+-------+ | 0 5 0 | 0 0 7 | 0 0 0 | | 0 0 0 | 0 4 5 | 7 0 0 | | 0 0 0 | 1 0 0 | 0 3 0 | +-------+-------+-------+ | 0 0 1 | 0 0 0 | 0 6 8 | |
DLX之数独问题的解决
heyker的专栏
03-29 892
<br />数独是一个非常经典的智力游戏。它的游戏的规则是这样的：在一个9x9的方格中，你需要把数字1-9填写到空格当中，并且使方格的每一行和每一列中都包含1-9这九个数字。同时还要保证，空格中用粗线划分成9个3x3的方格也同时包含1-9这九个数字。<br />如下例题：<br /><br />其解为：<br /><br /><br />在计算科学理论中，这一类问题的解答被称之为NPC问题中的Hitting Set Problem，中文名应该叫做碰集问题。该类问题可以通过转换成为精确覆盖问题，其中以行表示概
POJ 3074 Sudoku (DLX解经典数独)
Gatevin的专栏
10-02 1270
题目大意： 给出一个数独求解, 题目保证有唯一解 要求每行每列每个九宫格都恰好包含数字1~9 大致思路： 学习DLX的简单练习 构造矩阵的方法如下： 一共324列 刚开始没考虑到每个格子只能填一个数样例没过, 再加上81列表示每个格子的唯一性才通过样例... 矩阵的构造方法见代码注释 代码如下： Result  :  Accepted     Memory  :
DLX精确覆盖解数独问题
新博客地址:sensirly.github.io
08-23 2095
关于Dancing Links的介绍最好仔细阅读一下Knuth的论文，那篇翻译的文章也不错，这位仁兄的 博客比较易懂http://blog.csdn.net/sunny606/article/details/7833551 通过阅读论文主要有如下几点体会： 1.精确覆盖的最基本模型是：在一个01矩阵中选择若干个行，使得没列都包含且仅包含一个1 2.Dangcing links的逻辑与
3074 DLX解决数独
Geek
01-03 764
数独的DLX构造：9*9个点每个点有9种选择，这构成了DLX的729行，每行、列、阵有限制，均为9行（/列/阵），然后每行（/列/阵）都有九种数的情况，于是就有了3*9*9列，但是因为一个位置只能选一个，所以又有9*9列，每列连接一个点的九种选数情况。     最终有4*9*9=324列，9*9*9=729行。 具体看https://blog.csdn.net/qq_40061421/arti...
uva 1309 数独【DLX】
ACMer不要报考高校代码为13627的移通学院！
08-16 540
dancing link,数独，uva 1309
UVA 1469 Sudoku Extension【加强版数独 DLX】
ACMer不要报考高校代码为13627的移通学院！
08-17 428
大多数参照我写的上一篇博客，这次多了一些条件 对于0~9的情况，处理方法几乎一样。 对于O,处理方法则略加修改，相当于只能填写2468 E则为13579 对于其他字母，则构建新一些列，表示【A字母，写1，A字母是2，A字母是3 …… Z字母是1，Z字母是2，Z字母是3】 然后把这些列对应上去，直接跑DLX就能AC了。 #include #inc
关于用舞蹈链DLX算法求解数独的解析
weixin_30537391的博客
08-07 407
欢迎访问——该文出处-博客园-zhouzhendong 去博客园看该文章--传送门 描述 在做DLX算法题中，经常会做到数独类型的题目，那么，如何求解数独类型的题目？其实，学了数独的构建方法，那么DLX算法的精髓——构建矩阵也就慢慢的浮现了。 问题 假设有一个9*9的数独，我们限制每行每列以及每个3*3的小区域有且仅有1~9这些数各一个，现在我们要把1~9共9个数字各9个填入...
Java版本的DLX解决数独算法
cggwz的信息飞船
01-29 556
DLX又称作精确覆盖问题，而今天要说的就是把解数独这个问题转化为一个精确覆盖问题，然后来解决它。 其实这是一个很好的解决问题的思路，很多问题都可以转化为一个精确覆盖问题，然后用接下来这个算法来解决它。 关于DLX的思想，网上有不少的解释，这里我就不再赘述，我会在我的另一篇博客里讲解原理。 首先是整个代码的结构。 总共分为四个类，分别是： 主类（StartPoint） 转换器类（Transfer）...
DLX算法模板详解与应用
DLX重复覆盖模板提供了一个高效的方法来解决一些组合优化问题，通过链表操作和回溯搜索，可以在复杂度较高的问题中找到所有可能的解或最优解。理解和熟练运用这个模板对于ACM竞赛选手来说是非常有益的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值