LeetCode-搜索专题总结

最新推荐文章于 2023-04-11 11:12:45 发布
最新推荐文章于 2023-04-11 11:12:45 发布
阅读量414 收藏
点赞数
分类专栏： coding 文章标签： LeetCode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_hzc/article/details/84785494
版权

搜索

深度优先搜索和广度优先搜索是常考题型，广泛运用于树和图中。

BFS

广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。

第一层：

  • 0 -> {6,2,1,5}

第二层：

  • 6 -> {4}
  • 2 -> {}
  • 1 -> {}
  • 5 -> {3}

第三层：

  • 4 -> {}
  • 3 -> {}

每一层遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj。利用这个结论，可以求解最短路径等 最优解 问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径。

在程序实现 BFS 时需要考虑以下问题：

  • 队列：用来存储每一轮遍历得到的节点；
  • 标记：对于遍历过的节点，应该将它标记，防止重复遍历。

计算在网格中从原点到特定点的最短路径长度

[[1,1,0,1],
 [1,0,1,0],
 [1,1,1,1],
 [1,0,1,1]]

1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。

public int minPathLength(int[][] grids, int tr, int tc) {
    final int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    final int m = grids.length, n = grids[0].length;
    Queue<Pair<Integer, Integer>> queue = new LinkedList<>();
    queue.add(new Pair<>(0, 0));
    int pathLength = 0;
    while (!queue.isEmpty()) {
        int size = queue.size();
        pathLength++;
        while (size-- > 0) {
            Pair<Integer, Integer> cur = queue.poll();
            int cr = cur.getKey(), cc = cur.getValue();
            grids[cr][cc] = 0; // 标记
            for (int[] d : direction) {
                int nr = cr + d[0], nc = cc + d[1];
                if (nr < 0 || nr >= m || nc < 0 || nc >= n || grids[nr][nc] == 0) {
                    continue;
                }
                if (nr == tr && nc == tc) {
                    return pathLength;
                }
                queue.add(new Pair<>(nr, nc));
            }
        }
    }
    return -1;
}

最短单词路径

127. Word Ladder (Medium)

Input:
beginWord = "hit",
endWord = "cog",
wordList = ["hot","dot","dog","lot","log","cog"]

Output: 5

Explanation: As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog",
return its length 5.

Input:
beginWord = "hit"
endWord = "cog"
wordList = ["hot","dot","dog","lot","log"]

Output: 0

Explanation: The endWord "cog" is not in wordList, therefore no possible transformation.

题目描述：找出一条从 beginWord 到 endWord 的最短路径，每次移动规定为改变一个字符，并且改变之后的字符串必须在 wordList 中。

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (null == beginWord || 0 == beginWord.length() || null == endWord || 0 == endWord.length()) {
            return 0;
        }
        wordList.add(beginWord);
        int n = wordList.size();
        int start = n - 1;
        int end = 0;
        for (String str : wordList) {
            if (!endWord.equals(str)) {
                end++;
            } else {
                break;
            }
        }
        if (n == end) {
            return 0;
        }
        List<Integer>[] graph = getList(wordList);
        return getPath(graph, start, end);
    }
    public int getPath(List<Integer>[] graph, int start, int end) {
        int n = graph.length;
        Queue<Integer> queue = new LinkedList<>();
        boolean[] marked = new boolean[n];
        marked[start] = true;
        queue.add(start);
        int path = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            path++;
            while (size-- > 0) {
                int position = queue.poll();
                for (int next : graph[position]) {
                    if (next == end) {
                        return path;
                    }
                    if (marked[next]) {
                        continue;
                    }
                    marked[next] = true;
                    queue.add(next);
                }
            }
        }
        return 0;
    }
    public List<Integer>[] getList(List<String> wordList) {
        int n = wordList.size();
        List<Integer>[] graph = new List[n];
        for (int i = 0; i < n; i++) {
            graph[i] = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                String temp = wordList.get(j);
                if (connect(wordList.get(i), temp)) {
                    graph[i].add(j);
                }
            }
        }
        return graph;
    }
    public boolean connect(String s1, String s2) {
        int difference = 0;
        for (int i = 0; i < s1.length(); i++) {
            if (s1.charAt(i) != s2.charAt(i)) {
                difference++;
            }
        }
        return difference == 1;
    }
}

DFS

广度优先搜索一层一层遍历，每一层得到的所有新节点，要用队列存储起来以备下一层遍历的时候再遍历。

而深度优先搜索在得到一个新节点时立即对新节点进行遍历：从节点 0 出发开始遍历，得到到新节点 6 时，立马对新节点 6 进行遍历，得到新节点 4；如此反复以这种方式遍历新节点，直到没有新节点了，此时返回。返回到根节点 0 的情况是，继续对根节点 0 进行遍历，得到新节点 2，然后继续以上步骤。

从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 可达性 问题。

在程序实现 DFS 时需要考虑以下问题：

  • 栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
  • 标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。

查找最大的连通面积

695. Max Area of Island (Easy)

[[0,0,1,0,0,0,0,1,0,0,0,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,1,1,0,1,0,0,0,0,0,0,0,0],
 [0,1,0,0,1,1,0,0,1,0,1,0,0],
 [0,1,0,0,1,1,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,1,0,0],
 [0,0,0,0,0,0,0,1,1,1,0,0,0],
 [0,0,0,0,0,0,0,1,1,0,0,0,0]]

class Solution {
    int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    int cur = 0;
    public int maxAreaOfIsland(int[][] grid) {
        if (null == grid || 0 == grid.length) {
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;
        int max = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (1 == grid[i][j]) {
                    cur = 0;
                    dfs(grid, i, j);
                    max = Math.max(max, cur);
                }
            }
        }
        return max;
    }
    public void dfs(int[][] grid, int x, int y) {
        int m = grid.length;
        int n = grid[0].length;
        if (grid[x][y] == 0) {
            return ;
        } else if (grid[x][y] == 1) {
            grid[x][y] = 0;
            cur++;
        }
        for (int i = 0; i < 4; i++) {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if (xx >= 0 && xx < m && yy >= 0 && yy < n) {
                dfs(grid, xx, yy);
            }
        }
    }
}

矩阵中的连通分量数目

200. Number of Islands (Medium)

Input:
11000
11000
00100
00011

Output: 3

可以将矩阵表示看成一张有向图。

class Solution {
    int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    public int numIslands(char[][] grid) {
        if (null == grid || 0 == grid.length) {
            return 0;
        }
        int m = grid.length;
        int n = grid[0].length;
        int islands = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    dfs(grid, i, j);
                    islands++;
                }
            }
        }
        return islands;
    }
    public void dfs(char[][] grid, int x, int y) {
        int m = grid.length;
        int n = grid[0].length;
        if ('0' == grid[x][y]) {
            return ;
        } else if ('1' == grid[x][y]){
            grid[x][y] = '0'; 
        }
        for (int i = 0; i < 4; i++) {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if (xx >= 0 && xx < m && yy >= 0 && yy < n) {
                dfs(grid, xx, yy);
            }
        }
    }
}

好友关系的连通分量数目

547. Friend Circles (Medium)

Input:
[[1,1,0],
 [1,1,0],
 [0,0,1]]

Output: 2

Explanation:The 0th and 1st students are direct friends, so they are in a friend circle.
The 2nd student himself is in a friend circle. So return 2.

题目描述：好友关系可以看成是一个无向图，例如第 0 个人与第 1 个人是好友，那么 M[0][1] 和 M[1][0] 的值都为 1。

class Solution {
    public int findCircleNum(int[][] M) {
        if (null == M || 0 == M.length) {
            return 0;
        }
        int m = M.length;
        int circles = 0;
        boolean[] visit = new boolean[m];
        for (int i = 0; i < m; i++) {
            if (!visit[i]) {
                dfs(M, i, visit);
                circles++;
            }
        }
        return circles;
    }
    public void dfs(int[][] M, int i, boolean[] visit) {
        visit[i] = true;
        int m = M.length;
        for (int k = 0; k < m; k++) {
            if (!visit[k] && 1 == M[i][k]) {
                dfs(M, k, visit);
            }
        }
    }
}

填充封闭区域

130. Surrounded Regions (Medium)

For example,
X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:
X X X X
X X X X
X X X X
X O X X

题目描述：使被 ‘X’ 包围的 ‘O’ 转换为 ‘X’。

先将最外侧一层搜索一遍，再处理里层。

class Solution {
    int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    public void solve(char[][] board) {
        if (null == board || 0 == board.length) {
            return ;
        }
        int m = board.length;
        int n = board[0].length;
        for (int i = 0; i < m; i++) {
            dfs(board, i, 0);
            dfs(board, i, n - 1);
        }
        for (int i = 1; i < n - 1; i++) {
            dfs(board, 0, i);
            dfs(board, m - 1, i);
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == 'A') {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
    }
    public void dfs(char[][] board, int x, int y) {
        int m = board.length;
        int n = board[0].length;
        if (board[x][y] != 'O') {
            return ;
        }
        board[x][y] = 'A';
        for (int i = 0; i < 4; i++) {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if (xx >= 0 && xx < m && yy >= 0 && yy < n) {
                dfs(board, xx, yy);
            }
        }
    }
}

能到达的太平洋和大西洋的区域

417. Pacific Atlantic Water Flow (Medium)

Given the following 5x5 matrix:

  Pacific ~   ~   ~   ~   ~
       ~  1   2   2   3  (5) *
       ~  3   2   3  (4) (4) *
       ~  2   4  (5)  3   1  *
       ~ (6) (7)  1   4   5  *
       ~ (5)  1   1   2   4  *
          *   *   *   *   * Atlantic

Return:
[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (positions with parentheses in above matrix).

左边和上边是太平洋，右边和下边是大西洋，内部的数字代表海拔，海拔高的地方的水能够流到低的地方，求解水能够流到太平洋和大西洋的所有位置。

class Solution {
    int[][] dir = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    boolean[][] Pacific;
    boolean[][] Atlantic;
    List<int[]> list;
    public List<int[]> pacificAtlantic(int[][] matrix) {
        list = new ArrayList<>();
        if (null == matrix || 0 == matrix.length) {
            return list;
        }
        int m = matrix.length;
        int n = matrix[0].length;
        Pacific = new boolean[m][n];
        Atlantic = new boolean[m][n];
        for (int i = 0; i < n; i++) {
            dfs(matrix, 0, i, Pacific);
        }
        for (int i = 1; i < m; i++) {
            dfs(matrix, i, 0, Pacific);
        }
        for (int i = 0; i < m; i++) {
            dfs(matrix, i, n - 1, Atlantic);
        }
        for (int i = 0; i < n - 1; i++) {
            dfs(matrix, m - 1, i, Atlantic);
        }
        for (int i = 0; i < m ; i++) {
            for (int j = 0; j < n; j++) {
                if (Pacific[i][j] && Atlantic[i][j]) {
                    list.add(new int[]{i, j});
                }
            }
        }
        return list;
    }
    public void dfs(int[][] matrix, int x, int y, boolean[][] vis) {
        if (vis[x][y]) {
            return ;
        }
        vis[x][y] = true;
        int m = matrix.length;
        int n = matrix[0].length;
        for (int i = 0; i < 4; i++) {
            int xx = x + dir[i][0];
            int yy = y + dir[i][1];
            if (xx >= 0 && xx < m && yy >= 0 && yy < n && matrix[xx][yy] >= matrix[x][y]) {
                dfs(matrix, xx, yy, vis);
            }
        }
    }
}
HUANG Zichen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
leetcode-leetcode-cli-plugins:leetcode-cli的第3方插件
06-29
leetcode leetcode-cli-plugins leetcode-cli 的第 3 方插件。 什么是 如何使用 如何使用 插件 名称 描述 增强的命令 按公司或标签过滤问题 list 不要在同一台计算机上使 Chrome 的会话过期 login 不要在同一台...
leetcode-搜索总结
许诗宇的博客
09-29 363
leetcode-278-第一个错误的版本(first bad version)-java 二分查找法中，mid不能用 int mid=(begin+last)/2; 要用 int mid=begin+(last-begin)/2; 因为第一种情况begin+last可能会溢出，导致出错 ...
(算法笔试) Leetcode101之搜索算法
Auto_manager的博客
04-11 125
高的岛屿的雨水可以流到不高于自己的相邻岛屿上，与海相邻的岛屿雨水可以直接流入海里。给定一个单词和词典，单词每次可以修改一个字符得到一个新单词，如果新单词在词典中，这次修改是可行的，输出单词到目标单词的最短转换序列，可以不存在转换序列。同一行同一列同一斜线的皇后可以互相攻击，求在n*n的棋盘上放n个皇后，使得皇后之间不互相攻击的所有可能。给定一个树，选择一个节点作为根节点，使得其树的高度最小，返回所有可能的根节点。给定一个m*n的矩阵，将所有被X包围的O变成X。求最大的岛屿面积，相邻的1的土地为同一个岛屿。
leetcode（专题汇总）
qq_46517733的博客
12-08 2981
专题汇总1.数组2.链表3.哈希表4.字符串5.栈与队列6.二叉树7.回溯算法8.贪心算法9.动态规划 1.数组 2.链表 3.哈希表 4.字符串 5.栈与队列 6.二叉树 7.回溯算法 8.贪心算法 9.动态规划
LeetCode——BFS
努力努力再努力L
12-04 213
BFS 目录 BFS 介绍 计算在网格中从原点到特定点的最短路径长度 组成整数的最小平方数数量 最短单词路径 1. BFS 介绍 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。 需要注意的是，遍历过的节点不能再次被遍历。 第一层： 0 -> {6,2,1,5} 第二层： 6 -> {4} 2 -> {} 1 -&g...
Leetcode 题解 - 搜索--BFS(1):计算在网格中从原点到特定点的最短路径长度
qq_40320556的博客
05-22 1760
深度优先搜索和广度优先搜索广泛运用于树和图中，但是它们的应用远远不止如此。 BFS 广度优先搜索一层一层地进行遍历，每层遍历都以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。 第一层： 0 -> {6,2,1,5} 第二层： 6 -> {4} 2 -> {} 1 -> {} 5 -> {3...
leetcode中文版-leetcode-cheat:leetcode-cheat的发布
06-29
leetcode中文版leetcode作弊 leetcode-cheat 的发布 它是什么 ？ 这是一个chrome 扩展，可以帮助您更高效地使用 leetcode。您可以从 重要: leetcode-cheat 现在只支持中文版。 也就是说不完全支持leetcode.com，但是...
leetcode中文版-LeetCode-Notebook:https://leetcode-cn.com/u/ml-zimingmeng/
06-29
总结的 。分类刷题可以帮助我们有针对性地进行训练，对特定的题目类型形成自己的思维方式。 最后，重要的题目要多做。很多题目我们做一遍其实很难真正掌握，当我们第二遍去做时，尽量要独立完成，分析时间复杂度和...
leetcode2sumc-leetcode-cli:leetcode-cli
06-30
leetcode 2 和 c leetcode-cli 注意：这个存储库是为了临时使用而分叉的。 注意：从 webbrowser 复制 cookie 并使用leetcode user -c可以临时修复不能。 一个享受 leetcode 的高效 cli 工具！ 非常感谢 leetcode.com...
leetcode答案-LeetCode-solutions:LeetCode-解决方案
06-30
leetcode 答案leetcode-答案 一个存储我对 Leetcode 问题的所有答案的存储库。 目前回答的问题 数字 名称 困难 1 二和 简单的 2 两个数字相加 中等的 3 无重复字符的最长子串 中等的 7 反转整数 简单的 9 回文数 ...
1091. Shortest Path in Binary Matrix(Medium)——计算在网格中从原点到特定点的最短路径长度
待到春花烂漫时
10-21 3890
前言： 刷了一段时间的LeetCode，准备找一些个人觉得比较好的题目分享给大家，同时也方便自己总结。 本题目为广度优先遍历（BFS）算法的一道典型例题。 题目： 在一个N ×N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。 一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格C_1, C_2, ..., C_k组成： 相邻单...
LeetCode力扣刷题——一切皆可搜索
指北针_N的博客
10-12 714
搜索、深度优先搜索dfs、广度优先搜索bfs、回溯法、n皇后问题、岛屿问题。因为栈与递归的调用原理相同，而递归相对便于实现，因此刷题时笔者推荐使用递归式写法，同时也方便进行回溯（见下节）。我们从 1 号节点开始遍历，假如遍历顺序是从左子节点到右子节点，那么按照优先向着“广”的方向前进的策略，队列顶端的元素变化过程为 [1]->[2->3]->[4]，图的表示方法是，每个位置代表一个节点，每个节点与上下左右四个节点相邻。
搜索（DFS）---好友关系的连通分量数目
weixin_30567225的博客
06-30 172
好友关系的连通分量数目 547. Friend Circles (Medium) Input: [[1,1,0], [1,1,0], [0,0,1]] Output: 2 Explanation:The 0th and 1st students are direct friends, so they are in a friend circle. The 2nd student himse...
Leetcode 529 扫雷游戏
BIggyGuan的博客
08-20 145
题目描述 给定一个代表游戏板的二维字符矩阵。 ‘M’ 代表一个未挖出的地雷，‘E’ 代表一个未挖出的空方块，‘B’ 代表没有相邻（上，下，左，右，和所有4个对角线）地雷的已挖出的空白方块，数字（‘1’ 到 ‘8’）表示有多少地雷与这块已挖出的方块相邻，‘X’ 则表示一个已挖出的地雷。 现在给出在所有未挖出的方块中（‘M’或者’E’）的下一个点击位置（行和列索引），根据以下规则，返回相应位置被点击后对应的面板： 如果一个地雷（‘M’）被挖出，游戏就结束了- 把它改为 ‘X’。 如果一个没有相邻地雷的空方块（
LeetCode刷题——搜索（python语言）
qq_26274961的博客
03-01 1087
LeetCode刷题——搜索（python语言） 一、搜索 搜索简单来说分为查找和遍历。 查找分为有序查找（二分查找）和无序查找（顺序查找，二叉搜索树）。 顺序查找：一个挨一个找，从头找到尾，属于暴力算法。效率低 二叉搜素树，保证一个条件就是左子树的值小于根节点的值小于右子树的值。这样中序遍历获得从小到大的元素 二分查找：前提是已经排好序，可以将待查找元素和中间位置元素比较，然后修改左右指针。 遍历分为深度优先搜索（DFS）和广度优先搜索（BFS）。 深度优先搜索（DFS）主要的遍历思想是栈（stac
go语言刷题：1091. 计算在网格中从原点到特定点的最短路径长度
lanseali的博客
04-02 412
1、从 {0，0}出发【加入队列】，经过 八个方向 2、每次到达一个点，只要满足条件，就加入队列，加入队列意味着下一轮会从该节点出发 [也就是 A点出发到达B点，下次以B点为起点出发到达C点，每次到达一个点后，就以到达的点为起点] 3、已经被走过的点就不用再走了，应为那个点说明有人提前到过了 4、 只有当前到达的点 是 右下角的点 就可以直接返回，不需要遍历剩余的 注： 因为是最短路径，需要明确并认同，最先到达右下角的一次走法，最短路径可以理解为，多个人A从点出发去B点，每个人的速度相同，那么最先到达B点.
Leetcode 两数之和
萧海的博客
09-11 204
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。 你可以按任意顺序返回答案。 示例 1： 输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例 2： 输入：nums = [3,2,4], target =
LeetCode刷题之搜索（Java）
YCF8746的博客
02-08 844
一、深度优先搜索 基本模型：基于栈的递归 void dfs(step) { 判断边界 尝试每一种可能 for(int i=0;i<n;++i) { 继续下一步 dfs(step+1); } 返回 } DFS力扣例题 695.岛屿的最大面积 分析： 对是陆地的位置向四个方向进行深度优先搜索，如果下一个位置仍然是陆地，则加上由新陆地向四个方向搜索的值。遍历过的陆地应该设置为0，以避免重复被计入。 题解： class Solution { public static i
计算在网格中从原点到特定点的最短路径长度
qq_39638957的博客
09-18 742
[[1,1,0,1], [1,0,1,0], [1,1,1,1], [1,0,1,1]] 题目描述：1 表示可以经过某个位置，求解从 (0, 0) 位置到 (tr, tc) 位置的最短路径长度。 采用bfs方法： import java.util.*; public class ShortestPath { public static void main(St...
idea leetcode-edito乱码
最新发布
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值