leetcode37.解数独——学习笔记

最新推荐文章于 2024-09-21 10:02:17 发布
最新推荐文章于 2024-09-21 10:02:17 发布
阅读量310 收藏
点赞数
分类专栏： Leetcode练习 文章标签： leetcode java 递归算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hokachi/article/details/122429509
版权

题目：力扣https://leetcode-cn.com/problems/sudoku-solver/

class Solution {
    public void solveSudoku(char[][] board) {
        getNext(board);
    }

    private static List<String> getPossibleStatus(char[][] board,int x,int y){
        List<String> ans = new ArrayList<String>();
        ans.add("1");
        ans.add("2");
        ans.add("3");
        ans.add("4");
        ans.add("5");
        ans.add("6");
        ans.add("7");
        ans.add("8");
        ans.add("9");

        //检查行
        for(int i=0;i<9;i++){
            if(board[x][i]!='.'){
                if(board[x][i]==(char)i){
                    ans.remove("1");
                }else if(board[x][i]=='2'){
                    ans.remove("2");
                }else if(board[x][i]=='3'){
                    ans.remove("3");
                }else if(board[x][i]=='4'){
                    ans.remove("4");
                }else if(board[x][i]=='5'){
                    ans.remove("5");
                }else if(board[x][i]=='6'){
                    ans.remove("6");
                }else if(board[x][i]=='7'){
                    ans.remove("7");
                }else if(board[x][i]=='8'){
                    ans.remove("8");
                }else if(board[x][i]=='9'){
                    ans.remove("9");
                }
            }
        }
        //检查列
        for(int i=0;i<9;i++){
            if(board[i][y]!='.'){
                if(board[i][y]=='1'){
                    ans.remove("1");
                }else if(board[i][y]=='2'){
                    ans.remove("2");
                }else if(board[i][y]=='3'){
                    ans.remove("3");
                }else if(board[i][y]=='4'){
                    ans.remove("4");
                }else if(board[i][y]=='5'){
                    ans.remove("5");
                }else if(board[i][y]=='6'){
                    ans.remove("6");
                }else if(board[i][y]=='7'){
                    ans.remove("7");
                }else if(board[i][y]=='8'){
                    ans.remove("8");
                }else if(board[i][y]=='9'){
                    ans.remove("9");
                }
            }
        }
        //检查九宫格
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                if(board[(x/3)*3+i][(y/3)*3+j]!='.'){
                    if(board[(x/3)*3+i][(y/3)*3+j]=='1'){
                        ans.remove("1");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='2'){
                        ans.remove("2");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='3'){
                        ans.remove("3");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='4'){
                        ans.remove("4");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='5'){
                        ans.remove("5");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='6'){
                        ans.remove("6");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='7'){
                        ans.remove("7");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='8'){
                        ans.remove("8");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='9'){
                        ans.remove("9");
                    }
                }
            }
        }
        return ans;
    }

    //填入数据
    private static char[][] fillNum(char[][] board,int x,int y,char ch){
        board[x][y] = ch;
        return board;
    }

    //更新
    private static void getNext(char[][] board){
        boolean flag = true;
        for(int a=0;a<9;a++) {
            for (int b = 0; b < 9; b++) {
                if (board[a][b] == '.') {
                    flag = false;
                }
            }
        }
        if(flag){
            return;
        }
        for(int x=0;x<9;x++) {
            for (int y=0;y<9;y++) {
                if (board[x][y] == '.') {
                    List<String> ans = new ArrayList<String>();
                    ans = getPossibleStatus(board, x, y);
                    if (ans.size() == 1) {//找到唯一值
                        String temp = ans.get(0);
                        char[] target = temp.toCharArray();
                        board = fillNum(board, x, y, target[0]);
                        getNext(board);
                    }
                }
            }
        }
    }
}

 说明：首先，这份代码是一份不能AC的代码【已AC】。它暂时只能解决每一步都只有一个选择的数独，如果遇到某一步有两个或以上的选择（但最终解只有一个）它就可能陷入陷阱，以至于到最后很可能是得不到数独的解。

（例如这种数独是可以成功求解，如下图）

 

 （当出现以下数独时，就会陷入陷进，出现解答错误）

思路：根据三个要求（1）每行的数不能重复（2）每列的数不能重复（3）九宫格内的数不能重复  求出每个格子最后可以填的数，将这些数放入一个列表中。如果列表的长度为1，即表明该格子只有一种选择，那么唯一可选的数就是解，将这个数填入数独中。以此类推，按上述方法多次循环遍历二维数组期望可以得到解。

1.这个方法是用于求每个格子可供选择的数。

    private static List<String> getPossibleStatus(char[][] board,int x,int y){
        //......
    }

2.每个格子最初可供选择的都有1-9九个数字，后面根据三个要求逐一排除。

        List<String> ans = new ArrayList<String>();
        ans.add("1");
        ans.add("2");
        ans.add("3");
        ans.add("4");
        ans.add("5");
        ans.add("6");
        ans.add("7");
        ans.add("8");
        ans.add("9");

3.检查行，并在列表中删除行中出现过的元素。

        //检查行
        for(int i=0;i<9;i++){
            if(board[x][i]!='.'){
                if(board[x][i]==(char)i){
                    ans.remove("1");
                }else if(board[x][i]=='2'){
                    ans.remove("2");
                }else if(board[x][i]=='3'){
                    ans.remove("3");
                }else if(board[x][i]=='4'){
                    ans.remove("4");
                }else if(board[x][i]=='5'){
                    ans.remove("5");
                }else if(board[x][i]=='6'){
                    ans.remove("6");
                }else if(board[x][i]=='7'){
                    ans.remove("7");
                }else if(board[x][i]=='8'){
                    ans.remove("8");
                }else if(board[x][i]=='9'){
                    ans.remove("9");
                }
            }
        }

4.检查列，并在列表中删除列中出现过的元素。

        //检查列
        for(int i=0;i<9;i++){
            if(board[i][y]!='.'){
                if(board[i][y]=='1'){
                    ans.remove("1");
                }else if(board[i][y]=='2'){
                    ans.remove("2");
                }else if(board[i][y]=='3'){
                    ans.remove("3");
                }else if(board[i][y]=='4'){
                    ans.remove("4");
                }else if(board[i][y]=='5'){
                    ans.remove("5");
                }else if(board[i][y]=='6'){
                    ans.remove("6");
                }else if(board[i][y]=='7'){
                    ans.remove("7");
                }else if(board[i][y]=='8'){
                    ans.remove("8");
                }else if(board[i][y]=='9'){
                    ans.remove("9");
                }
            }

5.检查九宫格，并在列表中删除九宫格中出现过的元素。设每个九宫格的“起点”在最左上角位置，那么起点的下标可以用  (x/3)*3  和  (y/3)*3  求出，然后分别加i、j对九宫格进行遍历。

        //检查九宫格
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                if(board[(x/3)*3+i][(y/3)*3+j]!='.'){
                    if(board[(x/3)*3+i][(y/3)*3+j]=='1'){
                        ans.remove("1");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='2'){
                        ans.remove("2");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='3'){
                        ans.remove("3");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='4'){
                        ans.remove("4");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='5'){
                        ans.remove("5");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='6'){
                        ans.remove("6");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='7'){
                        ans.remove("7");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='8'){
                        ans.remove("8");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='9'){
                        ans.remove("9");
                    }
                }
            }

6.写一个填入数据的方法。

    //填入数据
    private static char[][] fillNum(char[][] board,int x,int y,char ch){
        board[x][y] = ch;
        return board;
    }

7.这个方法是用于更新填入数据后的数独。利用递归的方法，若数独没有被填满则会继续调用getNext()，直至数独被全部填满。

    //更新
    private static void getNext(char[][] board){
        //......
    }

8.设置递归出口。遍历数独，若数独中存在'.'即表示没有完成，需要继续；若数独中不存在'.'就可以跳出递归。

        boolean flag = true;
        for(int a=0;a<9;a++) {
            for (int b = 0; b < 9; b++) {
                if (board[a][b] == '.') {
                    flag = false;
                }
            }
        }
        if(flag){
            return;
        }

9.遍历数独，如果发现'.'即那个格子是待填入数据的，利用之前写好的getPossibleStatus()方法获取该格子可供选择的数字，若只有一个可供选择的数字，那便是找到解了，调用fillNum()方法将该数字填入数独中。完成上述步骤，此时会得到一个更新后的数独，然后我们再调用getNext()对新的数独故技重施，重复上述步骤。

        for(int x=0;x<9;x++) {
            for (int y=0;y<9;y++) {
                if (board[x][y] == '.') {
                    List<String> ans = new ArrayList<String>();
                    ans = getPossibleStatus(board, x, y);
                    if (ans.size() == 1) {//找到唯一值
                        String temp = ans.get(0);
                        char[] target = temp.toCharArray();
                        board = fillNum(board, x, y, target[0]);
                        getNext(board);
                    }
                }
            }
        }
    }

成功AC的代码如下：

class Solution {
    public void solveSudoku(char[][] board) {
        getNext(board,0,0);
    }
    private static List<String> getPossibleStatus(char[][] board,int x,int y){
        List<String> ans = new ArrayList<String>();
        ans.add("1");
        ans.add("2");
        ans.add("3");
        ans.add("4");
        ans.add("5");
        ans.add("6");
        ans.add("7");
        ans.add("8");
        ans.add("9");
 
        //检查行
        for(int i=0;i<9;i++){
            if(board[x][i]!='.'){
                if(board[x][i]==(char)i){
                    ans.remove("1");
                }else if(board[x][i]=='2'){
                    ans.remove("2");
                }else if(board[x][i]=='3'){
                    ans.remove("3");
                }else if(board[x][i]=='4'){
                    ans.remove("4");
                }else if(board[x][i]=='5'){
                    ans.remove("5");
                }else if(board[x][i]=='6'){
                    ans.remove("6");
                }else if(board[x][i]=='7'){
                    ans.remove("7");
                }else if(board[x][i]=='8'){
                    ans.remove("8");
                }else if(board[x][i]=='9'){
                    ans.remove("9");
                }
            }
        }
        //检查列
        for(int i=0;i<9;i++){
            if(board[i][y]!='.'){
                if(board[i][y]=='1'){
                    ans.remove("1");
                }else if(board[i][y]=='2'){
                    ans.remove("2");
                }else if(board[i][y]=='3'){
                    ans.remove("3");
                }else if(board[i][y]=='4'){
                    ans.remove("4");
                }else if(board[i][y]=='5'){
                    ans.remove("5");
                }else if(board[i][y]=='6'){
                    ans.remove("6");
                }else if(board[i][y]=='7'){
                    ans.remove("7");
                }else if(board[i][y]=='8'){
                    ans.remove("8");
                }else if(board[i][y]=='9'){
                    ans.remove("9");
                }
            }
        }
        //检查九宫格
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                if(board[(x/3)*3+i][(y/3)*3+j]!='.'){
                    if(board[(x/3)*3+i][(y/3)*3+j]=='1'){
                        ans.remove("1");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='2'){
                        ans.remove("2");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='3'){
                        ans.remove("3");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='4'){
                        ans.remove("4");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='5'){
                        ans.remove("5");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='6'){
                        ans.remove("6");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='7'){
                        ans.remove("7");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='8'){
                        ans.remove("8");
                    }else if(board[(x/3)*3+i][(y/3)*3+j]=='9'){
                        ans.remove("9");
                    }
                }
            }
        }
        return ans;
    }
 
    //填入数据
    private static char[][] fillNum(char[][] board,int x,int y,char ch){
        board[x][y] = ch;
        return board;
    }
 
    //更新方法改为递归
    //更新
    private static boolean getNext(char[][] board,int x, int y){
        if(x==9){
            //所有行已填充，返回true，标志该遍历路线填充成功
            return true;
        }
        if(y==9){
            //超过最后一列格子时，跳到下一行的第一列
            return getNext(board, x+1, 0);
        }
        if(board[x][y]!='.'){
            //已有数字的格子跳过
            return getNext(board, x, y+1);
        }
        //获取所有可以填的数字
        List<String> ans = getPossibleStatus(board, x, y);
        if(ans.size() == 0){
            //没有可以填的数字，返回false，标志该遍历路线填充失败
            return false;
        }
        for(int i=0;i<ans.size();i++){
            //所有可以填的数字依次试验
            String temp = ans.get(i);
            char[] target = temp.toCharArray();
            board = fillNum(board, x, y, target[0]);
            boolean flag = getNext(board, x, y+1);
            //flag表示当前格子填充数字ans[i]后往后遍历是否可以填充成功
            if(flag){
                //返回true,标志该遍历路线填充成功
                return true;
            }
            //flag为false表示当前格子不能填充数字ans[i]，将其回复为点
            fillNum(board, x, y, '.');
        }
        //没有找到可以填充到当前格子，并使得后续遍历填充成功的数字（说明上一步填充有错误），返回false,标志该遍历路线填充失败
        return false;
    }
}

 通过各种莽夫操作和求助大佬，虽然整份代码的质量不高，但不管怎样也算是AC了......

特别感谢bekote的帮助！

Hokachi
关注
专栏目录
数独基本规则_10 分钟学会数独
weixin_34593388的博客
12-17 7100
不了解数独的人，请先看我第一篇文章数独的规则以及元素现在你应该知道数独的基本规则，以及行、列和宫避免你没看前面那篇文章，我解释一下我用到的坐标体系R 代表行，C 代表列，B 代表宫R1C1 指第一行第一列那个格子R23C1 指第一列的第二行和第三行 2 个格子R1C23 指第一行的第二列和第三列 2 个格子B1 代表第一宫本文只是数独的基础技巧和快速入门，如果都学会还想继续深入，请等待我的后续文章...
（基于java） 算法笔记 —— 搜索算法
Terio的博客
06-11 1256
搜索算法的简单学习笔记 1、算法解释 常见的优先搜索算法：深度优先搜索（DFS）和广度优先搜索（BFS），广泛在图和树等结构中进行搜索 2、深度优先搜索 总是对新节点调用遍历，看起来向着“深度”方向前进 搜索到一个新的节点后，立即对该新节点进行遍历 遍历需要先入后出的栈；也可以使用与栈等价的递归 栈与递归调用的原理相同 递归便于实现，同时方便进行回溯（刷题推荐） 栈便于理解，不易出现递归栈满（工程推荐） 可用来检测环路 记录每个遍历过的节点的父节点 若一个节点被再次遍历且父节点不同，则说明有环
《编程之美》读书笔记(七)：数独游戏解析
热门推荐
薛笛的专栏
06-30 1万+
 《编程之美》读书笔记(七)：数独游戏解析  前言：说实话，所有游戏都是有一定规律可循的，只要掌握游戏规则通关就会变得容易，所以像九连环和魔方这样的游戏会产生看一眼之后就闭着眼睛完成的高手出现。但是数独游戏有所不同，如果其初始状态的生成过程充分随机且空白比较多的话就不那么容易解决，所以数独矩阵的生成就是本题的关键。以往我的关注点主要在补充书中算法的遗漏或不足上面，但是由于感觉这个游戏确实挺
leetcode36.有效的数独——学习笔记
Hokachi的博客
01-09 493
题目：力扣https://leetcode-cn.com/problems/valid-sudoku/ class Solution { public boolean isValidSudoku(char[][] board) { for(int num=0;num<9;num++){ boolean a = checkLine(board,num); boolean b = checkColumn(board,num);
数独游戏前端学习笔记及后续解数独方法
qq_37880655的博客
02-21 1500
学习于默课网学习视频的整理笔记 基于我本地已经安装了nmp/node所以只添加了yarn 安装yarn: npm install -g yarn 安装成功后，查看版本号yarn --version 项目里 到这一步我遇到了问题 本地安装babel-loader和bable-preset-es2015报错 后经度娘是版本问题我把package.json文件里&amp;amp;quot;gulp&amp;amp;quot;: &amp;amp;quot;
打卡：听课笔记数独游戏
qq_39053247的博客
02-25 265
题目：玩家需要根据9*9盘上的已知数字，推理出所有剩余空格的数字，并满足每一行，每一列，每一个同色九宫内的数字均含有1-9，不重复 005300000 800000020 070010500 400005300 010070006 003200080 060500009 004000030 000009700 描述： import java.util.Scanner; pu...
LeetCode算法学习笔记——递归、回溯和分治
luoyihao123456的博客
05-09 250
LeetCode算法学习笔记——递归、回溯和分治
速成算法笔记，Github上已收获近60K+star！力压LeetCode只为面试
xingduan5153的博客
08-19 1462
金九银十将至，秋招算法有救了！！！ 《吃透算法套路——只为面试》GitHub连续霸榜首页数周，star即将突破60k，受欢迎程度可见一斑： 文档的作者最先提出「刷题要掌握模板和套路」的观点，刷题就是应对面试拿 offer，再别整什么《算法导论》这种花里胡哨的了。 该文档的内容全部选自 LeetCode 和牛客网的原题，你只要按照文章顺序刷题，保你一个月速成算法。 还在为动态规划系列问...
玩转算法面试笔记
Meow5的博客
04-19 406
title: 玩转算法面试笔记 主要分章节记录了LeetCode的题，看题目的话可以从第二章开始 1、聊聊算法面试 1.1、对一组数据进行排序，你会怎么做呢 1、这组数据有什么样的特征? 有没有可能包含有大量重复的元素? 如果有这种可能的话，三路快排是更好地选择。(Java种快排的基本实现就是使用三路快排) 是否大部分数据距离它正确的位置很近?是否近乎有序? 如果是这样的话，插入排序是更好地选择。（如对银行的业务按照业务发生的时间进行排序，大多数业务先发生也先结束，少数处理的业务先发生但是处理.
第二轮 Python 刷题笔记一：数组
TEDxPY
05-23 1695
经过四十多天缓慢的刷题，现在进度大概是刷了八十多道 LeetCode 题，最近也在吸取过来人的经验，仍然需要对刷题计划进行调整。 首先明确下目标，我是有了 Python 基础，刷题是想掌握更多提升代码质量的算法、接触并了解更底层的原理和知识点。 结合着目标，便很快找到之前刷题过程中存在的不足： 经常花费大量时间冥思苦想某道题，最终可能采用辛苦的方法做出来，就这么提交后没有继续跟进和整理，错过相关更巧妙算法知识的学习。 之前的模式是刷完题后写题解，回顾下最初思路，代码实现加注释，比对下时间空间表现，时间充裕
最全算法学习资料汇总（附链接：书籍/网站/课程/面试/项目....），99%的人都收藏了！！
Codeforest_cloud的博客
01-06 1083
算法是计算机科学领域最重要的基石之一，算法工程师也是数据科学领域最重要的岗位之一。因此，今天小会整理出一些算法相关学习资源，包括书籍、算法刷题网站、项目资源、视频课程、面试要领这5个方面，欢迎大家收藏并转发哦。 争取做到，看完这一篇，算法相关学习资料全掌握！话不多说，这就开始吧！ 一：书籍推荐 【入门阶段】 1、啊哈！算法（豆瓣评分7.7） 这是一本充满智慧和趣味的算法入门书。没有枯燥的描述，没有难懂的公式，一切以实际应用为出发点，通过幽默的语言配以可爱的插图来讲解算法。你更像是在阅读一个个轻松的小故事或是
python学习笔记（四）：回溯法解决数独问题
Mikumiku339的博客
11-09 1128
python学习笔记（四）：回溯法解决数独问题数独定义回溯法的一般步骤代码 数独定义 数独，整个网格又分成9个3×3的小正方形网格，每个格子有一个数字（1~9），数独满足如下要求： （1）每个数字在每一行只出现一次 （2）每个数字在每一列只出现一次 （3）每个数字在每个3×3的小区域中也只出现一次 如下图所示。 回溯法的一般步骤 while(结束条件未满足） { if(本层可行的解决方案存在）： 执行 if(本层为最后一层): 输出结果 return
【学习笔记】【力扣题库】有效的数独 难度：中等
h2809871142的博客
03-28 1545
判断一个9x9 的数独是否有效。只需要根据以下规则，验证已经填入的数字是否有效即可。 数字1-9在每一行只能出现一次。 数字1-9在每一列只能出现一次。 数字1-9在每一个以粗实线分隔的3x3宫内只能出现一次。 上图是一个部分填充的有效的数独。 数独部分空格内已填入了数字，空白格用'.'表示。 示例1: 输入: [ ["5","3",".",".",...
安卓开发笔记——数独游戏
不疯魔不成活
05-30 3320
　　最近在做一个安卓小游戏的开发，主要是将小时候和小伙伴们在村里田间玩的一个小游戏在安卓手机中实现。先拿数独游戏开发来练练手，做了一点笔记，分享我遇到的坑和收获。1、Super的用法：Super必须写在构造方法的第一行2、this是指向对象本身的指针3、安卓四大组件：Activity、Service、Broadcast Receiver、Content Provider4、Activity的跳转实...
C++速通LeetCode中等第3题-盛最多水的容器
lyx的博客
09-18 315
双指针法：两个指针分别指向左右边界，记录最大面积，由于面积由短板决定，两个指针中较短的短指针向内移动一格，再次记录最大面积，直到两指针相遇，得出答案。
2024/9/21 leetcode 21.合并两个有序链表 2.两数相加
最新发布
su_xu_chao的博客
09-21 779
将两个升序链表合并为一个新的链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。[][0]l2。
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 386
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
Leetcode 470. 用 Rand7() 实现 Rand10()
qq_51350957的博客
09-18 1051
Leetcode 470. 用 Rand7() 实现 Rand10()
leetcode 2031. 1 比 0 多的子数组个数
12-16
leetcode 2031题是一道有关于子数组的问题。问题的要求是求出给定数组中，1的个数比0多的子数组的个数。我们可以通过遍历数组的每个元素，...以上就是针对leetcode 2031题的问题，求解1比0多的子数组个数的详细解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hokachi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值