leetcode刷题记录【数据结构类题目】—Python代码+详细注释

已于 2022-12-11 21:49:39 修改
阅读量197 收藏
点赞数
分类专栏： Pyhon 文章标签： python leetcode
于 2021-12-02 13:14:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41743584/article/details/121675043
版权

题目：735. 行星碰撞
难度：中等
算法：栈模拟

# 2022.07.15
class Solution:
    def asteroidCollision(self, ats: List[int]) -> List[int]:
        stack = []
        for at in ats:
            to_stack = True  # ---------AAA
            while to_stack and stack and stack[-1] > 0 and at < 0:  # 栈里的是正数，at是负数
                # 两个if里都写上等于，处理两边相等一起爆炸的情况
                if stack[-1] >= -at:  # 栈里的正数比过了at:
                    to_stack = False  # 换下一个at(while里面要写to_stack)——标记为false不入栈---AAA
                if stack[-1] <= -at:  # 栈里的正数没比过at
                    stack.pop()  # 干掉并换栈里的下一个比
            if to_stack:  # ---------AAA
                # 正数入栈，或栈里的正数都没比过负数at，就把at入栈
                stack.append(at)
        return stack

题目：565. 数组嵌套
难度：中等
算法：数组嵌套/有向图

# 2022.07.19
class Solution:
    def arrayNesting(self, nums: List[int]) -> int:
        ans = 0
        n = len(nums)
        mark = [False] * n
        for i in range(n):
            # mark数组为什么不放在这儿：因为循环过一次的数，是个环，没必要再次循环
            cnt = 0
            # 每次while循环遍历完一个环后，开始遍历下一个环；如果无环，会由while跳过；如果已被标记，会由for循环直接跳过
            while not mark[i]:
                mark[i] = True
                i = nums[i]
                cnt += 1
            ans = max(ans, cnt)
        return ans

题目：731. 我的日程安排表 II
难度：中等
算法：数组区间比较

# 2022.07.20
class MyCalendarTwo:

    def __init__(self):
        self.booked = []  # 预定过的有效区间
        self.duplicate = []  # 预定两次的区间

    def book(self, start: int, end: int) -> bool:
        # 如果跟两次重合的重合了，返回false
        if any(start < e and end > s for (s, e) in self.duplicate):
            return False
        # 如果跟一次的重合了，把重合部分加入两次重合list
        for (s, e) in self.booked:
            if start < e and end > s:
                self.duplicate.append((max(start, s), min(end, e)))
        # 没丢弃的都记录下来跟后面的继续比较
        self.booked.append((start, end))
        return True

# Your MyCalendarTwo object will be instantiated and called as such:
# obj = MyCalendarTwo()
# param_1 = obj.book(start,end)

题目：1331. 数组序号转换
难度：简单
算法：哈希表

# 2022.07.28
class Solution:
    def arrayRankTransform(self, arr: List[int]) -> List[int]:
        # 去重+排序
        tmp = sorted(set(arr))
        # 哈希
        dic = {value: index for index, value in enumerate(tmp, 1)}
        # 从哈希表中取arr中对应的index
        ans = [dic[num] for num in arr]
        return ans

题目：206. 反转链表
难度：简单
算法：反转链表

# 2022.08.12
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 迭代做法，；类似冒泡排序
        # 来个空链表
        pre = None
        # cur从头开始准备，后面会逐步转变指向
        cur = head
        while cur:
            # 创建临时节点暂存cur的下一个节点（右）
            tmp = cur.next
            # 把cur下一个节点转而指向另一侧（左）
            cur.next = pre
            # pre后移（右）
            pre = cur
            # cur后移（右）
            cur = tmp
        return pre

参考思路：https://leetcode.cn/problems/reverse-linked-list/solution/dong-hua-yan-shi-206-fan-zhuan-lian-biao-by-user74/

题目：165. 比较版本号
难度：中等
算法：两个数组对比

# 2022.12.11
class Solution:
    def compareVersion(self, version1: str, version2: str) -> int:
        # fillvalue来制定那些缺失值，当参数长度不一时，zip和较短的保持一致，itertools.zip_longest()和较长的保持一致。
        for ver1, ver2 in zip_longest(version1.split('.'), version2.split('.'), fillvalue = 0):
            ver1_int, ver2_int = int(ver1), int(ver2)
            if ver1_int != ver2_int:
                return 1 if ver1_int > ver2_int else -1
        return 0

# list2 = ["a", "b", "c", "d","e"]  #len = 5
# list3 = [1, 2, 3, 4]  #len = 4
# print(list(itertools.zip_longest(list1, list3, fillvalue = "克里马擦")))
# #[('A', 1), ('B', 2), ('C', 3), ('D', 4), ('E', '克里马擦')]

------------------before---------------------
20211201
题目1446. 连续字符
难度：简单
题解：一列字符串中count重复最多的个数，如果第i个和第i-1个一样，就count+1，刷新到ans中，记录下一个时把count更新为1；
注意点：i-1需要考虑边界问题

20211206
题目1005. K 次取反后最大化的数组和
难度：简单
题解：排序后count非正数的个数，（1）考虑一种特殊情况：非正数数的个数cnt小于k且相减为奇数，将不得不留成负数的（选绝对值最小的）从绝对值之和里减去；（2）其他情况，选k与cnt较小的将负数转成正数。
1005题目地址

20211228
题目475. 供暖器
难度：中等
题解：对每个house找到minimum距离的heater，称之为热水器距离，然后取所有houses的热水器距离中的最大值。（后续改代码的时候发现，其实只要比较每个house左右两个距离最近的heaters即可，不用每个heater都去比较，而且记录最小值即可，不用把整个数组存下来）

注意点：边界问题—out of range
在这里插入图片描述
没加heaters = heaters + [-inf,inf]之前，报错index out of range，基于上图用例
（1）第一次打印出来发现k有负数，由于k -= 1的存在使得k变成负数超出范围，于是加了heaters = heaters + [-inf]，还是报错index out of range；
（2）第二次打印出来发现k4 = 2，使得mini = min(tmp, heaters[k]-houses[i])中的heaters[k] 超出范围，尝试把k -= 1移到前面来，但是mini = min(tmp, heaters[k]-houses[i])中的heaters[k] 实际值就不对了，于是改成加了heaters = heaters + [inf]，由于heaters[k]=inf时，对式子mini = min(tmp, heaters[k]-houses[i])无影响，所以此方法行得通。
475题目地址

class Solution:
    def findRadius(self, houses: List[int], heaters: List[int]) -> int:
        # 第一次写的，把比较结果存成了数组，时间超出限制了
        # mini = [0]*len(houses)
        # tmp = [[0]*len(heaters)]*len(houses)
        # for i in range(len(houses)):
        #     mini[i] = min(list(map(abs,(houses[i] - heaters[k] for k in range(len(heaters))))))
        #     # for k in range(len(heaters)):
        #     #     tmp[i][k] =  abs(houses[i] - heaters[k])
        #     # mini[i] =  min(tmp[i])

        #     # mini[i] = min(abs(houses[i] - heaters[k] for k in heaters))
        # return max(mini)
        
        # 第二次写，每次比较结果只存成一个数（因为边界问题，打印了很多参数定位bug）
        ans, i, k = 0, 0, 0
        heaters = heaters + [-inf,inf]
        houses.sort()
        heaters.sort()
        print("houses:",houses)
        print("heaters:",heaters)

        while i < len(houses):
            tmp = inf
            print("i:",i)
            while k < len(heaters) and heaters[k] <= houses[i]:
                print("k1:",k)
                print(len(heaters))
                tmp = min(tmp, houses[i]-heaters[k])
                print("tmp:",tmp)
                k += 1
                print("k4:",k) 
            mini = min(tmp, heaters[k]-houses[i])
            print("k5:",k)
            print("mini:",mini)
            ans = max(ans, mini)
            print("ans:",ans)
            i += 1
            print("k2:",k)
            k -= 1
            print("k3:",k)
        return ans

题目1995. 统计特殊四元组
难度：简单
题解：数据范围小，直接暴力求解了，后续有空可以看看怎么降复杂度
1995题地址

2022.03.04
题目剑指 Offer 38. 字符串的排列
难度：中等
题解：回溯+【排序&去重】
38题题目地址
debug记录

s = 'abc'
nums = list(s)
nums = sorted(nums)
# 为下面去重做准备
nums = sorted(nums)
def dfs(nums, depth, path, used, ans):
    print("nums长度=",len(nums))
    print("树深depth", depth)
    print("判断下树深depth是否=nums长度")
    print("-------")
    if depth == len(nums):
        print("=======")
        print("记入答案的path",path)
        print("=======")
        ans.append(''.join(path))  # path携写成nums的时候输出了6个“abc”
        return
    for i in range(len(nums)):
        # 去重--由于已排序，从第二个起，如果和上一个字符一样且上一个没记录进路径
        print("第",i,"次进循环：")
        print("-------")
        if i > 0 and nums[i] == nums[i - 1] and used[i - 1] == False:
            print("nums[",i,"]：",nums[i]," & nums[",i-1,"]:", nums[i-1])
            continue
        if used[i] == False:
            print("判断后第",i,"次进循环：")
            print("-------")
            print("used判断后", used)
            print("-------")
         # 加入
            path.append(nums[i])
            print("加入path", path)
            print("-------")
            used[i] = True
            print("used加入后变为true值", used)
            print("-------")
         # depth+1
            print("自我执行增加树深depth=",depth)
            print("-------")
            dfs(nums, depth + 1, path, used, ans)
            print("↓↓↓↓")
            print("树深depth增加depth+1后",depth)
            print("-------")
         # 撤销
            path.pop()
            used[i] = False
            print("used撤销后变为false值", used)
            print("-------")
# 初始化
depth = 0
path = []
used = [False for _ in range(len(nums))]
ans = []
# 执行dfs函数
dfs(nums, depth, path, used, ans)
print(ans)

nums长度= 3
树深depth 0
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
判断后第 0 次进循环：
-------
used判断后 [False, False, False]
-------
加入path ['a']
-------
used加入后变为true值 [True, False, False]
-------
自我执行增加树深depth= 0
-------
nums长度= 3
树深depth 1
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
第 1 次进循环：
-------
判断后第 1 次进循环：
-------
used判断后 [True, False, False]
-------
加入path ['a', 'b']
-------
used加入后变为true值 [True, True, False]
-------
自我执行增加树深depth= 1
-------
nums长度= 3
树深depth 2
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
第 1 次进循环：
-------
第 2 次进循环：
-------
判断后第 2 次进循环：
-------
used判断后 [True, True, False]
-------
加入path ['a', 'b', 'c']
-------
used加入后变为true值 [True, True, True]
-------
自我执行增加树深depth= 2
-------
nums长度= 3
树深depth 3
判断下树深depth是否=nums长度
-------
=======
记入答案的path ['a', 'b', 'c']
=======
↓↓↓↓
树深depth增加depth+1后 2
-------
used撤销后变为false值 [True, True, False]
-------
↓↓↓↓
树深depth增加depth+1后 1
-------
used撤销后变为false值 [True, False, False]
-------
第 2 次进循环：
-------
判断后第 2 次进循环：
-------
used判断后 [True, False, False]
-------
加入path ['a', 'c']
-------
used加入后变为true值 [True, False, True]
-------
自我执行增加树深depth= 1
-------
nums长度= 3
树深depth 2
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
第 1 次进循环：
-------
判断后第 1 次进循环：
-------
used判断后 [True, False, True]
-------
加入path ['a', 'c', 'b']
-------
used加入后变为true值 [True, True, True]
-------
自我执行增加树深depth= 2
-------
nums长度= 3
树深depth 3
判断下树深depth是否=nums长度
-------
=======
记入答案的path ['a', 'c', 'b']
=======
↓↓↓↓
树深depth增加depth+1后 2
-------
used撤销后变为false值 [True, False, True]
-------
第 2 次进循环：
-------
↓↓↓↓
树深depth增加depth+1后 1
-------
used撤销后变为false值 [True, False, False]
-------
↓↓↓↓
树深depth增加depth+1后 0
-------
used撤销后变为false值 [False, False, False]
-------
第 1 次进循环：
-------
判断后第 1 次进循环：
-------
used判断后 [False, False, False]
-------
加入path ['b']
-------
used加入后变为true值 [False, True, False]
-------
自我执行增加树深depth= 0
-------
nums长度= 3
树深depth 1
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
判断后第 0 次进循环：
-------
used判断后 [False, True, False]
-------
加入path ['b', 'a']
-------
used加入后变为true值 [True, True, False]
-------
自我执行增加树深depth= 1
-------
nums长度= 3
树深depth 2
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
第 1 次进循环：
-------
第 2 次进循环：
-------
判断后第 2 次进循环：
-------
used判断后 [True, True, False]
-------
加入path ['b', 'a', 'c']
-------
used加入后变为true值 [True, True, True]
-------
自我执行增加树深depth= 2
-------
nums长度= 3
树深depth 3
判断下树深depth是否=nums长度
-------
=======
记入答案的path ['b', 'a', 'c']
=======
↓↓↓↓
树深depth增加depth+1后 2
-------
used撤销后变为false值 [True, True, False]
-------
↓↓↓↓
树深depth增加depth+1后 1
-------
used撤销后变为false值 [False, True, False]
-------
第 1 次进循环：
-------
第 2 次进循环：
-------
判断后第 2 次进循环：
-------
used判断后 [False, True, False]
-------
加入path ['b', 'c']
-------
used加入后变为true值 [False, True, True]
-------
自我执行增加树深depth= 1
-------
nums长度= 3
树深depth 2
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
判断后第 0 次进循环：
-------
used判断后 [False, True, True]
-------
加入path ['b', 'c', 'a']
-------
used加入后变为true值 [True, True, True]
-------
自我执行增加树深depth= 2
-------
nums长度= 3
树深depth 3
判断下树深depth是否=nums长度
-------
=======
记入答案的path ['b', 'c', 'a']
=======
↓↓↓↓
树深depth增加depth+1后 2
-------
used撤销后变为false值 [False, True, True]
-------
第 1 次进循环：
-------
第 2 次进循环：
-------
↓↓↓↓
树深depth增加depth+1后 1
-------
used撤销后变为false值 [False, True, False]
-------
↓↓↓↓
树深depth增加depth+1后 0
-------
used撤销后变为false值 [False, False, False]
-------
第 2 次进循环：
-------
判断后第 2 次进循环：
-------
used判断后 [False, False, False]
-------
加入path ['c']
-------
used加入后变为true值 [False, False, True]
-------
自我执行增加树深depth= 0
-------
nums长度= 3
树深depth 1
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
判断后第 0 次进循环：
-------
used判断后 [False, False, True]
-------
加入path ['c', 'a']
-------
used加入后变为true值 [True, False, True]
-------
自我执行增加树深depth= 1
-------
nums长度= 3
树深depth 2
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
第 1 次进循环：
-------
判断后第 1 次进循环：
-------
used判断后 [True, False, True]
-------
加入path ['c', 'a', 'b']
-------
used加入后变为true值 [True, True, True]
-------
自我执行增加树深depth= 2
-------
nums长度= 3
树深depth 3
判断下树深depth是否=nums长度
-------
=======
记入答案的path ['c', 'a', 'b']
=======
↓↓↓↓
树深depth增加depth+1后 2
-------
used撤销后变为false值 [True, False, True]
-------
第 2 次进循环：
-------
↓↓↓↓
树深depth增加depth+1后 1
-------
used撤销后变为false值 [False, False, True]
-------
第 1 次进循环：
-------
判断后第 1 次进循环：
-------
used判断后 [False, False, True]
-------
加入path ['c', 'b']
-------
used加入后变为true值 [False, True, True]
-------
自我执行增加树深depth= 1
-------
nums长度= 3
树深depth 2
判断下树深depth是否=nums长度
-------
第 0 次进循环：
-------
判断后第 0 次进循环：
-------
used判断后 [False, True, True]
-------
加入path ['c', 'b', 'a']
-------
used加入后变为true值 [True, True, True]
-------
自我执行增加树深depth= 2
-------
nums长度= 3
树深depth 3
判断下树深depth是否=nums长度
-------
=======
记入答案的path ['c', 'b', 'a']
=======
↓↓↓↓
树深depth增加depth+1后 2
-------
used撤销后变为false值 [False, True, True]
-------
第 1 次进循环：
-------
第 2 次进循环：
-------
↓↓↓↓
树深depth增加depth+1后 1
-------
used撤销后变为false值 [False, False, True]
-------
第 2 次进循环：
-------
↓↓↓↓
树深depth增加depth+1后 0
-------
used撤销后变为false值 [False, False, False]
-------
['abc', 'acb', 'bac', 'bca', 'cab', 'cba']
NaH
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
algorithm-learning:leetcode刷题（Java，Python）和算法书籍
03-18
《algorithm-learning: leetcode刷题（Java，Python）和算法书籍》这个压缩包文件主要包含的是关于算法学习的资源，特别是针对LeetCode平台上的题目进行的编程实践，涉及的编程语言主要是Java和Python。LeetCode是一...
Leetcode题解-算法-动态规划（python版）
桑凯旋的博客
05-07 1478
1、最长回文子序列 确定状态 dp[i][j]：以下标 i 为起始点，下标 j 为结束点的子串的最长回文子序列长度。 状态转移方程 当 s[i] == s[j] 时，dp[i][j] = dp[i+1][j-1] + 2 当 s[i] != s[j] 时，dp[i][j] = max(dp[i+1, j], dp[i, j-1]) 算法流程 初始 dp[][] = 0 dp[i][i] = 1 返回：return dp[0][n-1] 从最后一行开始计算，每行从左向右计算 516. 最长
非leetcode刷题记录【工程化实现类题目】—Python代码+详细注释
weixin_41743584的博客
06-22 236
工程化实现题
LeetCode中等题合集 python
JM1307hhh的博客
05-28 714
leetcode中的中等题合集，每日一题，持续更新
Leetcode题解-算法-数学(python版)
桑凯旋的博客
05-19 829
1、进制转换 1.1 小于 n 的所有素数 204. 计数质数(Medium) 从 2 开始，每碰见一个素数，就将该素数的所有整数倍的数排除。 class Solution: def countPrimes(self, n: int) -> int: prime = [1] * n cnt = 0 for i in range(2, n): if prime[i]: cnt += 1
LeetCode简单题合集 python
JM1307hhh的博客
05-07 968
1672. 最富有客户的资产总量 class Solution: def maximumWealth(self, accounts: List[List[int]]) -> int: maxSum=0 #记录下最大值 for a in accounts: #遍历每个客户 if sum(a)>maxSum: #当前客户资产总和大于记录的最大值 maxSum=sum(a) retur
leetcode分类-LeetCode:LeetCode刷题记录
06-30
2. 解析注释：高质量的开源项目会有详细的代码注释，解释解题思路和关键步骤，这对于深化理解至关重要。 3. 测试用例：项目中可能包含针对每道题目的测试用例，帮助验证代码的正确性和通用性。 三、刷题策略与建议...
LeetCode:LeetCode刷题记录
04-15
在本压缩包“LeetCode刷题记录”中，主要包含了个人在LeetCode平台上进行编程挑战的练习记录。LeetCode是一个在线平台，它提供了各种算法题目，旨在帮助开发者提升编程技能和算法理解。这个记录可能包括了从易到难的...
LeetCode：LeetCode刷题思路
02-18
LeetCode 是一个在线平台，专为程序员提供一系列算法和数据结构题目，以帮助他们提升编程技能，准备面试，以及在实际工作中解决问题。本资源“LeetCode刷题思路”似乎是一个关于如何有效地解决LeetCode上问题的指南...
my-leetcode_road:记录我的leetcode刷题过程
03-15
LeetCode 提供的题目涵盖了许多编程语言，如 Java、Python、C++ 等，涵盖了基础到高级的各种算法和数据结构问题。这些题目分为简单、中等和困难三个级别，帮助不同水平的程序员逐步提高。 1. **数据结构**：在 ...
Python刷Leetcode 数据结构与算法学习，刷题学习笔记。
Mr_zhouxin123的博客
07-05 1040
Python刷Leetcode 数据结构与算法学习，刷题学习笔记。
【LeetCode刷题】动态规划相关题目（附Python代码）
D2Ooo的博客
07-28 410
整理了一些LeetCode上可以用动态规划做的题目
【python基础教程】3
最新发布
l202226的博客
03-16 1141
python工程化，python的爬虫基础内容，python的后端基础内容，浏览器f12控制台解释，fastapi使用教程，爬虫的hello world
Python工程代码结构（以pytorch工程HTCN为例）
weixin_42641207的博客
10-11 2307
首先右键HTCN文件夹，选择open as a Pycharm Project进入到Pycharm界面，观察到左侧workspace内有很多文件夹。我们分别来讨论一下其作用。 1.cfgs（configurations） 这里存放的都是工程的配置文件，所谓配置文件储存的就是工程的一些超参数。单独实现一个cfgs是便于模型的保存与复制。我们点开cfgs文件夹，发现其储存的结构如下： yml后缀文件是一种配置文件，其储存了resnet以及vgg作为backbone的时候各种网络的参数。yml与j.
笔试题（不在leetcode中的）
flytowns的博客
03-15 198
文章目录排序输出全部排序情况素数暴力判断是否为素数 排序 输出全部排序情况 vector<int> x; sort(x.begin(),x.end()); do { //每一次排序的情况 }while(next_permutation(x.begin(),x.end())); 素数 暴力判断是否为素数 bool iz(int x) { for(int k=2;k*k<=x;k++) { if(x%k==0) .
【每日一题】735. 行星碰撞
爱写bug的王六六
07-13 193
用双队列模拟栈
数据结构与算法LeetCode刷题（Python）
xiaoxy97的博客
10-07 1775
参考资料： 1、《面试算法LeetCode刷题班》 - 小象学院 2、csujedihy / lc-all-solutions 一、链表        1.  链表的必备知识要点(包括基础知识、刷题中使用的STL等知识)      2.  链表逆序(LeetCode 92 ,206. Reverse Linked List 1,2)      3.  求两个链表的交点(LeetCod...
leetcode刷题---数组---非递减数列
破浪会有时的博客
11-30 380
给你一个长度为 n 的整数数组，请你判断在 最多 改变 1 个元素的情况下，该数组能否变成一个非递减数列。 我们是这样定义一个非递减数列的： 对于数组中所有的 i (0 <= i <= n-2)，总满足 nums[i] <= nums[i + 1]。 示例 1: 输入: nums = [4,2,3] 输出: true 解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。 示例 2: 输入: nums = [4,2,1] 输出: false 解释: 你不能在只改变一个元素的情况下将
Leetcode 21-30 刷题笔记（非困难题目）
fxhhh123的博客
11-24 112
21.合并两个有序链表 该题目思路十分简单，就是两个指针指向两个链表即可然后进行比较结果从而指针移动，这里直接放上代码。 //合并两个有序链表 public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode head = new ListNode(); ListNode temp = head; while(l1 != null && l2 != null)
"详细代码解析：Leetcode刷题记录
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值