9*9方格数独数字问题解答

最新推荐文章于 2021-08-17 21:25:31 发布
最新推荐文章于 2021-08-17 21:25:31 发布
阅读量634 收藏
点赞数
文章标签： 游戏
原文链接：http://www.cnblogs.com/bailong/archive/2011/05/29/2061869.html
版权

近日，学校组织了一次软件设计大赛，题目是一道数独智力题，感觉还不错，现向大家分享一下。

数独是一个智力小游戏。一个9*9的棋盘，共有9行9列以及9个互不相交的3*3九宫格。里面某些格子开始已经填上了1-9中的一些数字。要求玩家在余下的空格中填上1-9中数字，使得每行，每列和每个3*3九宫格中都正好包含1-9数字各一个。数独游戏保证结果的存在和唯一性。

package game;

public class Game_3 {
//  存储字符
 private String s = "";
 // 要取的字符目录
 private static String c[] = {"1","2","3","4","5","6","7","8","9"};
 private static int flag=0;
 private static int max=9*8*7*6*5*4*3*2*1;
 private static String[] str=new String[max+1];
 private static String[][] arry=new String[9][9];
 public Game_3(){
  
 }
 public void show(int j, Game_3 t) {
  for (int i=0; i<c.length; i++) {
   if(!t.s.contains(c[i]))
    this.s = t.s + c[i];
   else
    continue;       
  if(j==1){
   str[flag]=this.s; 
   //System.out.println(str[flag]);
   flag++;
  }
  if((j-1!=0))
      new Game_3().show(j-1,this);
  else
   continue;
  }
 }
 public static void Flue(){
  int i,j,k,l,m,n,o,p,q;
  for(i=0;i<max;i++){
   Replace(0,arry,str[i]);
   for(j=0;j<max;j++){
    if(CompareTo(str[i],str[j])){
     Replace(1,arry,str[j]);
     if(Compare_Host_1_1(arry)){
      for(k=0;k<max;k++){
       if(CompareTo(str[i],str[k])&&CompareTo(str[j],str[k])){
        Replace(2,arry,str[k]);
        if(Compare_Host_1(arry)){
         for(l=0;l<max;l++){
          if(CompareTo(str[i],str[l])&&CompareTo(str[j],str[l])&&CompareTo(str[k],str[l])){
           Replace(3,arry,str[l]);
           for(m=0;m<max;m++){
            if(CompareTo(str[i],str[m])&&CompareTo(str[j],str[m])&&CompareTo(str[k],str[m])&&CompareTo(str[l],str[m])){
             Replace(4,arry,str[m]);
             if(Compare_Host_2_1(arry)){
              for(n=0;n<max;n++){
               if(CompareTo(str[i],str[n])&&CompareTo(str[j],str[n])&&CompareTo(str[k],str[n])&&CompareTo(str[l],str[n])&&CompareTo(str[m],str[n])){
                Replace(5,arry,str[n]);
                if(Compare_Host_2(arry)){
                 for(o=0;o<max;o++){
                  if(CompareTo(str[i],str[o])&&CompareTo(str[j],str[o])&&CompareTo(str[k],str[o])&&CompareTo(str[l],str[o])&&CompareTo(str[m],str[o])&&CompareTo(str[n],str[o])){
                   Replace(6,arry,str[o]);
                   for(p=0;p<max;p++){
                    if(CompareTo(str[i],str[p])&&CompareTo(str[j],str[p])&&CompareTo(str[k],str[p])&&CompareTo(str[l],str[p])&&CompareTo(str[m],str[p])&&CompareTo(str[n],str[p])&&CompareTo(str[o],str[p])){
                     Replace(7,arry,str[p]);
                     if(Compare_Host_3_1(arry)){
                      for(q=0;q<max;q++){
                       if(CompareTo(str[i],str[q])&&CompareTo(str[j],str[q])&&CompareTo(str[k],str[q])&&CompareTo(str[l],str[q])&&CompareTo(str[m],str[q])&&CompareTo(str[n],str[q])&&CompareTo(str[o],str[q])&&CompareTo(str[p],str[q])){
                        Replace(8,arry,str[q]);
                        if(Compare_Host_3(arry)){                                                  
                          Print_Arry(arry);                        
                        }                  
                       }
                      }
                     }                     
                    }
                   }
                  }
                 }
                }              
               }
              }
             }            
            }
           }
          }
         }
        }       
       }
      }
     }     
    }
   }
  }
 }

 public static boolean Compare_Host_1(String[][] arry){
  int i,j;
  boolean flag=true;
  for(i=0;i<3;i++){
   if(flag==false){
    break;
   }
   for(j=0;j<9;j++){
    if(i>=0&&i<3&&j<3&&j>=0){
     if(!Compare_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=0&&i<3&&j<6&&j>=3){
     if(!Compare_2(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=0&&i<3&&j<9&&j>=6){
     if(!Compare_3(arry[i][j])){
      flag=false;
      break;
     }
    }
   }
  }  
  return flag;
 }
 public static boolean Compare_Host_1_1(String[][] arry){
  int i,j;
  boolean flag=true;
  for(i=0;i<2;i++){
   if(flag==false){
    break;
   }
   for(j=0;j<9;j++){
    if(i>=0&&i<2&&j<3&&j>=0){
     if(!Compare_1_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=0&&i<2&&j<6&&j>=3){
     if(!Compare_2_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=0&&i<2&&j<9&&j>=6){
     if(!Compare_3_1(arry[i][j])){
      flag=false;
      break;
     }
    }
   }
  }
  return flag;
 }
 public static boolean Compare_Host_2(String[][] arry){
  int i,j;
  boolean flag=true;
  for(i=3;i<6;i++){
   if(flag==false){
    break;
   }
   for(j=0;j<9;j++){
       if(i>=3&&i<6&&j<3&&j>=0){
     if(!Compare_4(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=3&&i<6&&j<6&&j>=3){
     if(!Compare_5(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=3&&i<6&&j<9&&j>=6){
     if(!Compare_6(arry[i][j])){
      flag=false;
      break;
     }
    }
   }
  }
  return flag;
 }
 public static boolean Compare_Host_2_1(String[][] arry){
  int i,j;
  boolean flag=true;
  for(i=3;i<5;i++){
   if(flag==false){
    break;
   }
   for(j=0;j<9;j++){
       if(i>=3&&i<5&&j<3&&j>=0){
     if(!Compare_4_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=3&&i<5&&j<6&&j>=3){
     if(!Compare_5_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=3&&i<5&&j<9&&j>=6){
     if(!Compare_6_1(arry[i][j])){
      flag=false;
      break;
     }
    }
   }
  }
  return flag;
 }
 public static boolean Compare_Host_3(String[][] arry){
  int i,j;
  boolean flag=true;
  for(i=6;i<9;i++){
   if(flag==false){
    break;
   }
   for(j=0;j<9;j++){
    if(i>=6&&i<9&&j<3&&j>=0){
     if(!Compare_7(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=6&&i<9&&j<6&&j>=3){
     if(!Compare_8(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=6&&i<9&&j<9&&j>=6){
     if(!Compare_9(arry[i][j])){
      flag=false;
      break;
     }
    }
   }
  }
  return flag;
 }

 public static boolean Compare_Host_3_1(String[][] arry){
  int i,j;
  boolean flag=true;
  for(i=6;i<8;i++){
   if(flag==false){
    break;
   }
   for(j=0;j<9;j++){
    if(i>=6&&i<8&&j<3&&j>=0){
     if(!Compare_7_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=6&&i<8&&j<6&&j>=3){
     if(!Compare_8_1(arry[i][j])){
      flag=false;
      break;
     }
    }
    else if(i>=6&&i<8&&j<9&&j>=6){
     if(!Compare_9_1(arry[i][j])){
      flag=false;
      break;
     }
    }
   }
  }
  return flag;
 }

 public static boolean Compare_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=0;i<3;i++){
   for(j=0;j<3;j++){   
     if(r.equals(arry[i][j])){
      sign++;
     }         
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_1_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=0;i<2;i++){
   for(j=0;j<3;j++){   
     if(r.equals(arry[i][j])){
      sign++;
     }         
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_2(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=0;i<3;i++){
   for(j=3;j<6;j++){
     if(r.equals(arry[i][j])){
      sign++; 
    } 
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_2_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=0;i<2;i++){
   for(j=3;j<6;j++){
     if(r.equals(arry[i][j])){
      sign++; 
    } 
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_3(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=0;i<3;i++){
   for(j=6;j<9;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
    
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_3_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=0;i<2;i++){
   for(j=6;j<9;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
    
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_4(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=3;i<6;i++){
   for(j=0;j<3;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
    
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_4_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=3;i<5;i++){
   for(j=0;j<3;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
    
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_5(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=3;i<6;i++){
   for(j=3;j<6;j++){
     if(r.equals(arry[i][j])){
      sign++;
     }  
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_5_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=3;i<5;i++){
   for(j=3;j<6;j++){
     if(r.equals(arry[i][j])){
      sign++;
     }  
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_6(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=3;i<6;i++){
   for(j=6;j<9;j++){
     if(r.equals(arry[i][j])){
      sign++;
     }  
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_6_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=3;i<5;i++){
   for(j=6;j<9;j++){
     if(r.equals(arry[i][j])){
      sign++;
     }  
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_7(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=6;i<9;i++){
   for(j=0;j<3;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_7_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=6;i<8;i++){
   for(j=0;j<3;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_8(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=6;i<9;i++){
   for(j=3;j<6;j++){
     if(r.equals(arry[i][j])){
      sign++;
     }  
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_8_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=6;i<8;i++){
   for(j=3;j<6;j++){
     if(r.equals(arry[i][j])){
      sign++;
     }  
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_9(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=6;i<9;i++){
   for(j=6;j<9;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static boolean Compare_9_1(String r){
  int i,j;
  int sign=0;
  boolean flag=true;
  for(i=6;i<8;i++){
   for(j=6;j<9;j++){
     if(r.equals(arry[i][j])){
      sign++;
     } 
   }
  }
  if(sign==1)flag=true;
  else flag=false;
  return flag;
 }
 public static void Replace(int sign,String[][] arry,String s){
  for(int i=0;i<9;i++){
   arry[sign][i]=String.valueOf(s.charAt(i));
  }
 }
 public static boolean CompareTo(String s1,String s2){
  boolean sign=true;
   for(int i=0;i<s1.length();i++){
    if(s1.charAt(i)==s2.charAt(i)){
     sign=false;
     break;
    }
   } 
  return sign;
 }
 public static void Print_Arry(String[][] arry){
  for(int i=0;i<arry.length;i++){
   for(int j=0;j<arry[i].length;j++){
    System.out.print(arry[i][j]+"  ");
   }
   System.out.println();
  }
  System.out.println();
  System.out.println();
  System.out.println();
 }
 public static void Copy(String[][] arry_1,String[][] arry_2){
  for(int i=0;i<arry_1.length;i++)
   for(int j=0;j<arry_1[i].length;j++)
    arry_2[i][j]=arry_1[i][j];
 }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  new Game_3().show(9, new Game_3());
  Flue();
 }

}

转载于:https://www.cnblogs.com/bailong/archive/2011/05/29/2061869.html

weixin_30699955
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
九宫格数独游戏
qq_39980514的博客
04-11 1375
九宫格数独游戏 一个九宫格数独游戏，以下是思路和html文件，由于水平有限没有使用什么比较高级的语法，都是一些基础的东西，所以代码比较长。 逻辑思路 1.生成数独游戏 思路是把数独理解成一个二维数组，只要每次游戏开始随机生成一个符合九宫格规则的9*9二维数组即可。（如果不随机就可以记答案，游戏就没意思了） 1.1输入原型数组，这个数组要符合规则 1.2打乱这个数组生成答案数组：使用能保...
Python(+numpy)实现对9*9数独问题(单解或多解)的快速递归求解
01-20
Python(+numpy)实现对9*9数独问题的求解 利用Python(+numpy库)递归实现对9*9...无论是4*4还是9*9的数独游戏规则很简单很粗暴，拿9*9数独来说，规则可概括为 9组 1-9 共 81个数字（包含已给出的数字）填入 9*9 的方格
POJ - 2676 Sudoku-9X9方格数独填数
loycine的博客
04-14 1117
点击查看原文 9X9方格数独填数，主要就是9个3X3小方格的bool查重数组的设计， 这里利用 （i-1）/3，（j-1）/3的方式把小方格的点的向量合并成一个向量，再利用3进制的移位操作变换成线性，如此九个3x3小方格也能和行列一样查重了。 代码基本没变，在原文的基础上加了点注释，毕竟本人ACM菜鸡QAQ #include #include #include
将1~9放入9个[]中，使得[][][]+[][][]=[][][]等式成立（dfs）
兜率工的博客
02-21 1435
#include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;cstdio&gt; #include &lt;math.h&gt; #include &lt;float.h&gt; using namespace std; int book[10],total,a[10]; ...
数独问题
K.SHI的博客
12-25 1592
问题描述： 标准的数独游戏是在一个 9 X 9 的棋盘上填写 1 – 9 这 9 个数字，规则是这样的： 棋盘分成上图所示的 9 个区域（不同颜色做背景标出，每个区域是 3 X 3 的子棋盘），在每个子棋盘中填充 1 – 9 且不允许重复 ，下面简称块重复 每一行不许有重复值，每一列不许有重复值 题目类型：回溯算法代码如下：（严禁抄袭，请尝试自己动手实现。——Ldu1403）/* 该题和拉
数独九宫格
weixin_30338497的博客
09-25 565
数独九宫格游戏 一．题目说明 数独的游戏规则： 1、在9×9的大九宫格内，已给定若干数字，其他宫位留白，玩 家需要自己按照逻辑推敲出剩下的空格里是什么数字。 2、必须满足的条件：每一行与每一列都有1到9的数字，每个小 九宫格里也有1到9的数字，并且一个数字在每行、每列及每 个小九宫格里只能出现一次，既不能重复也不能少。 3、每个数独游戏都可根据给定的数字...
shudu_Java.rar_9*9数独java_java 数独_java数独_数独
09-24
数独问题的求解过程，可求解给定的9*9数独问题
9*9数独游戏 C++&ncurses 开发
02-12
初级项目9*9数独游戏C++开发源码，界面采用Linux的ncurses文字界面。算法实现生成地图都有效，亲测可玩
基于Matlab求解9x9数独（源码）.rar
03-26
1、资源内容：基于Matlab求解9x9数独（源码）.rar 2、适用人群：计算机，电子信息工程、数学等专业的学习者，作为“参考资料”参考学习使用。 3、解压说明：本资源需要电脑端使用WinRAR、7zip等解压工具进行解压，...
9阶数独问题1_九阶数独问题_
10-03
九阶数独问题，使用matlab编程实现的九阶数独问题
9*9数独解法
07-10
9*9数独的解法，使用深度搜索找到一个解即返回，欢迎交流
【SolveSudoku】解9*9数独
07-13
手动输入一个9*9数独，自动解出答案。
数独游戏,在9阶方阵中，包含了81个小格（九列九行），其中又再分成九个小正方形（称为宫），每宫有九小格。
07-15
数独游戏规则 在9阶方阵中，包含了81个小格（九列九行），其中又再分成九个小正方形（称为宫），每宫有九小格。 游戏刚开始时，盘面上有些小格已经填了数字（称为初盘），游戏者要在空白的小格中填入1到9的数字， 使得最后每行、每列、每宫都不出现重复的数字，而且每一个游戏都只有一个唯一的解答（称为终盘）。
9*9=81劫难？
影子
12-06 467
       以前看西游记，经常听长者们说起，唐哥哥必须要在九九八十一劫难之后才能去得到真经，为什么必须要经过八十一难之后才能去得到真经呢？你比如说唐哥哥非常的有管理天赋，在取经的路上对四个徒弟管理有方，不产生误会，是不是可以减少劫难的次数，早早的把真经取到手呢？还有就是我们的玉帝哥哥，要经过一万多次劫难，每一个劫难又要持续几万年才可以结束，最终修成玉帝。为什么要经过劫难呢？一直再思考。我们是以故...
数独游戏的设计与实现
weixin_30362801的博客
09-24 407
数独游戏的规则： 1.游戏会从一个部分带有数字的九宫格开始。 在9×9的大九宫格（即3格宽×3格高）方阵里，每一格又细分为一个小九宫格。 2.游戏开始，已给定若干数字，其它宫位留白，玩家需要自己按照逻辑推敲出剩下的空格里是什么数字。 3.填数字时必须满足以下条件：在空白的小格子里填上1~9中的数字，使得每个数字在“九宫格”的每行、每列、每个小九宫格中均只出现一次。 ...
判断是否是数独
图图是只猫
08-17 871
题目 数独是一类广受大众喜欢的填数游戏。最典型的数独由9*9的方格组成，其中会填入一些1~ 9的数字。玩家需要补上剩余格子的数字，使得每个格子所在的行、列、小九宫格都包含有1~9的数字，不重不漏。 现在小明已经做好了一些填好了所有数字的数独游戏题面，正准备挖空。但在此之前，他希望你帮忙检查一下题面是否正确，即做好的题面是否每个格子都满足所在行、列、小九宫格都包含1~9。 输入 第一行输入一个数T，表示小明已完成的数独题面个数。 之后每个题面输入共9行，每行9个数以空格隔开，表示填好的数独中的数字。 输出 输
《经典算法》数独问题
热门推荐
wyj823508的博客
08-24 1万+
题目： 数独问题：9*9的矩阵，要求每一行，每一列，每个九宫格都是1-9这九个数字且不能重复。 给定一9*9矩阵，里面有部分数空缺，要求找出满足上述要求的一个矩阵。 如： 思路： 根据该单元格所在行、列以及所在单元的九宫格来确定当前位置可填写那些数字，分两种情况，1:只有一个数字可以填写。2:有多个数字可以填写。这里只有当该处填写数字唯一才可填写，循环上述步骤知道填写完。 源码： ...
AcWing 166. 数独
dog_egg0327的博客
03-11 261
数独是一种传统益智游戏，你需要把一个 9×9 的数独补充完整，使得图中每行、每列、每个 3×3 的九宫格内数字 1∼9 均恰好出现一次。 请编写一个程序填写数独。 输入格式 输入包含多组测试用例。 每个测试用例占一行，包含 81 个字符，代表数独的 81 个格内数据（顺序总体由上到下，同行由左到右）。 每个字符都是一个数字（1−9 ）或一个 .（表示尚未填充）。 您可以假设输入中的每个谜题都只有一个解决方案。 文件结尾处为包含单词 end 的单行，表示输入结束。 输出格式 每个测试用例，输出一行数据，代表填
Gurobi求解标准数独问题
ilike_program的博客
12-29 2531
问题导入 数独问题就是将9×9的网格填充上1~9的整数值，同时保证每个整数在每一行、每一列和每个3×3方格只出现一次。网格中分布有一些线索，你的任务就是填充剩余的网格数字。对于此问题，可以使用0-1变量优化求解。 标准数独问题只要有解就行，无需设置目标函数，即：可行解就是数独问题的解。 决策变量 约束条件 1.对于给定的初始元素，都认为是等式约束： xijk=1∀k=cij∈C{{x}_{ij...
java用回溯法解决9*9数独问题
最新发布
05-12
`solve()`方法通过回溯法来解决数独问题，`isValid()`方法用来检查当前数字是否有效，`print()`方法用来输出结果。 在`main()`方法中，我们定义了一个数独矩阵，并将其传递给`SudokuSolver`类来解决。最后输出结果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值