二分查找及部分扩展

最新推荐文章于 2024-08-03 19:27:22 发布
最新推荐文章于 2024-08-03 19:27:22 发布
阅读量897 收藏 21
点赞数 24
分类专栏： 算法 文章标签： python 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79793605/article/details/135221705
版权

1.给定长度为n的数组，元素从小到大排列，不包含重复元素。查找并返回target的索引，不包含该元素返回-1.

第一次尝试：

def binary_search(nums, target):
    """二分查找"""
    # 双闭区间，左右操作对称，创建左指针和右指针,分别指向数组的首元素和尾元素
    i = 0
    j = len(nums) - 1
    # 计算中间元素,向下取整数
    m = (i + j) // 2
    # 当j小于i时，查找结束
    while i <= j:
        # 若中间元素小于目标元素，则目标元素在中间元素后，即区间[m + 1, j]
        if nums[m] < target:
            i = m + 1
        # 若中间元素大于目标元素，则目标元素在中间元素前，即区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 若中间元素等于目标元素，则找到目标元素，返回中间元素的索引
        else:
            return m
    # 若没找到元素，返回-1
    return -1


if __name__ == '__main__':
    nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(binary_search(nums, 2))

错误：

1.循环的过程中没有计算中间元素

第二次尝试：

def binary_search(nums, target):
    """二分查找"""
    # 双闭区间，左右操作对称，创建左指针和右指针,分别指向数组的首元素和尾元素
    i = 0
    j = len(nums) - 1
    # 当j小于i时，查找结束
    while i <= j:
        # 计算中间元素,向下取整数
        m = (i + j) // 2
        # 若中间元素小于目标元素，则目标元素在中间元素后，即区间[m + 1, j]
        if nums[m] < target:
            i = m + 1
        # 若中间元素大于目标元素，则目标元素在中间元素前，即区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 若中间元素等于目标元素，则找到目标元素，返回中间元素的索引
        else:
            return m
    # 若没找到元素，返回-1
    return -1


if __name__ == '__main__':
    nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(binary_search(nums, 2))

补充：

1.计算中间元素下标时，若i,j数过大可能超过int类型范围，此时可使用公式m = i + (j - i) // 2

2.长度为n的有序数组，不存在重复元素。将target插入到数组中，并保持其有序性。若数组中存在target，则插入到左方。返回插入后target在数组中的索引。

第一次尝试：

def binary_search_insertion(nums, target):
    """
    二分查找插入点
    1.当target存在时，数组中的target的索引就是插入位置，双闭区间
    2.当target不存在时,循环后，i会指向首个大于target的元素，j指向首个小于target的元素
    """
    # 创建左指针和右指针，分别指向列表首元素和尾元素
    i, j = 0, len(nums) - 1
    # 循环，直到i > j,即左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于target,则插入位置在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于target,则插入位置在区间[i, m - 1]中
        elif nums[m] > target:
            j = m - 1
    # 循环后，返回插入位置i
    return i


if __name__ == '__main__':
    nums = [1, 3, 5, 6, 7, 8, 9, 10]
    print(binary_search_insertion(nums, 4))

错误：

1.返回值没有满足题目要求，仅考虑到数组中没有目标元素target的情况

第二次尝试：

def binary_search_insertion(nums, target):
    """
    二分查找插入点
    1.当target存在时，数组中的target的索引就是插入位置
    2.当target不存在时,循环后，i会指向首个大于target的元素，j指向首个小于target的元素
    """
    # 创建左指针和右指针，分别指向列表首元素和尾元素,双闭区间
    i, j = 0, len(nums) - 1
    # 循环，直到i > j,即左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于target,则插入位置在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于target,则插入位置在区间[i, m - 1]中
        elif nums[m] > target:
            j = m - 1
        # 如果列表中有目标元素，则返回目标元素的索引
        else:
            return m
    # 循环后，返回插入位置i
    return i


if __name__ == '__main__':
    nums = [1, 3, 5, 6, 7, 8, 9, 10]
    print(binary_search_insertion(nums, 5))

3.长度为n的有序数组，存在重复元素。将target插入到数组中，并保持其有序性。若数组中存在重复target，则插入到最左方。返回插入后target在数组中的索引。

第一次尝试:

def binary_search_insertion(nums, target):
    # 创建左指针和右指针，闭区间
    i, j = 0, len(nums) - 1
    # 循环，直到i > j
    while i <= j:
        # 计算中间元素索引
        m = (i + j) // 2
        # 如果中间元素小于目标元素,说明目标元素在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于目标元素，说明目标元素在区间[i, m - 1]中
        elif nums[m] > target:
            j = m - 1
        # 查找到目标元素，但不知道左边和右边分别有多少元素
        # 但是可以知道，左边的元素小于等于目标元素，右边的元素大于等于目标元素
        # 所以，可以知道若左边还有等于目标元素的元素，应位于区间[i, m - 1]中
        else:
            j = m - 1
    # 循环后，i指向最左边的目标元素,j指向首个小于目标元素的元素
    return i


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 6, 7, 8, 9]
    print(binary_search_insertion(nums, 3))

4.长度为n的有序数组nums,可能包含重复元素。返回数组中最左target元素的索引。若不包含此元素，返回-1。即查找左边界

第一次尝试：
 

def binary_search_left_edge(nums, target):
    # 创建左指针和右指针，左指针指向数组首元素，右指针指向数组尾元素
    i, j = 0, len(nums) - 1
    # 循环,直到左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于目标元素,说明目标元素在中间元素的右边，即区间[m + 1, j]
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于目标元素，说明目标元素在中间元素的左边，即区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 如果中间元素等于目标元素，缩小右边界，寻找左边的目标元素
        # 循环后i指向最左边的目标元素，j指向首个小于目标元素的元素
        else:
            j = m - 1
    # 找不到目标元素时会出现两种情况
    # 1.目标元素大于列表尾元素，循环后i = len(nums)
    # 2.目标元素小于列表首元素,循环后i = 0,即nums[i] 不等于target
    if i == len(nums) or nums[i] != target:
        return -1
    return i


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 3, 7, 8, 9]
    print(binary_search_left_edge(nums, 0))

5.长度为n的数组nums，可能含重复元素。查找数组中最右的目标元素target的索引,若数组中不存在则返回-1。即查找右边界

第一次尝试:与查找左边界类似，更改nums[m] == target的条件即可，改为缩小左边界

def binary_search_right_edge(nums, target):
    # 创建左指针和右指针，指向列表中首元素和尾元素,闭区间
    i, j = 0, len(nums) - 1
    # 循环，直到右指针大于左指针
    while i <= j:
        # 计算中间元素索引
        m = (i + j) // 2
        # 如果中间元素小于目标元素，说明目标元素在中间元素的右边，即在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于目标元素，说明目标元素在中间元素的左边,即在区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 如果中间元素等于目标元素,缩小左边界，
        else:
            i = m + 1
    # 当找不到目标元素时，会出现两种情况
    # 1.目标元素大于数组中尾元素，循环后i指向len(nums)
    # 2.目标元素小于数组中首元素，循环后i指向nums[0],即nums[i] != target
    if i == len(nums) or nums[i] != target:
        return -1
    return i


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 3]
    print(binary_search_right_edge(nums, 3))

错误:
1.返回索引错误,i指向首个大于目标元素target的索引

第二次尝试：

在搜索元素插入位置时

1.目标元素在列表中，此时i指向目标元素，j指向首个小于目标元素的元素

2.目标元素不在列表中，此时i指向首个大于目标元素target的元素，j指向首个小于目标元素target的元素

在搜索边界时，更改了中间元素等于目标元素时执行的步骤，由返回插入索引变为缩小边界范围
1.求左边界，缩小右边界范围，直到左指针大于右指针，i指向左边界，j指向首个小于目标元素的元素
2.求右边界，缩小左边界范围，直到左指针大于右指针，j指向右边界，i指向首个大于目标元素的元素

def binary_search_right_edge(nums, target):
    # 创建左指针和右指针，指向列表中首元素和尾元素,闭区间
    i, j = 0, len(nums) - 1
    # 循环，直到右指针大于左指针
    while i <= j:
        # 计算中间元素索引
        m = (i + j) // 2
        # 如果中间元素小于目标元素，说明目标元素在中间元素的右边，即在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于目标元素，说明目标元素在中间元素的左边,即在区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 如果中间元素等于目标元素,缩小左边界，
        else:
            i = m + 1
    # 当找不到目标元素时，会出现两种情况
    # 1.目标元素大于数组中尾元素，循环后i指向len(nums)
    # 2.目标元素小于数组中首元素，循环后i指向nums[0],即nums[i] != target
    if j == len(nums) or nums[j] != target:
        return -1
    return j


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 3]
    print(binary_search_right_edge(nums, 3))

6.复用左边界查找右边界

将查找右边界target转换为查找左边界target + 1

第一次尝试：

def binary_search_left_edge(nums, target):
    """查找左边界"""
    # 创建左指针和右指针，左指针指向数组首元素，右指针指向数组尾元素
    i, j = 0, len(nums) - 1
    # 循环,直到左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于目标元素,说明目标元素在中间元素的右边，即区间[m + 1, j]
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于目标元素，说明目标元素在中间元素的左边，即区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 如果中间元素等于目标元素，缩小右边界，寻找左边的目标元素
        # 循环后i指向最左边的目标元素，j指向首个小于目标元素的元素
        else:
            j = m - 1
    # 找不到目标元素时会出现两种情况
    # 1.目标元素大于列表尾元素，循环后i = len(nums)
    # 2.目标元素小于列表首元素,循环后i = 0,即nums[i] 不等于target
    if i == len(nums) or nums[i] != target:
        return -1
    return i


def binary_search_right_edge(nums, target):
    """"复用查找左边界的方法查找右边界"""
    # 调用查找左边界的方法
    j = binary_search_left_edge(nums, target + 1) - 1
    # 找不到目标元素时会出现两种情况
    # 1.目标元素大于列表中尾元素，循环后i指向len(nums),此时j = len(nums) - 1,即nums[j] != target:
    # 2.目标元素小于列表中首元素，循环后i指向0,此时j = -1，即j == - 1
    if j == -1 or nums[j] != target:
        return -1
    return j


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 3, 7, 8, 9]
    print(binary_search_right_edge(nums, 3))

错误：

1.未将查找左边界函数中，没有找到目标元素执行步骤删除。复用左边界查找右边界时，target + 1在数组中很可能不存在，此时左边界查找函数找不到目标元素，返回-1，进而导致右边界查找错误

def binary_search_left_edge(nums, target):
    """查找左边界"""
    # 创建左指针和右指针，左指针指向数组首元素，右指针指向数组尾元素
    i, j = 0, len(nums) - 1
    # 循环,直到左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于目标元素,说明目标元素在中间元素的右边，即区间[m + 1, j]
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于目标元素，说明目标元素在中间元素的左边，即区间[i, m - 1]
        elif nums[m] > target:
            j = m - 1
        # 如果中间元素等于目标元素，缩小右边界，寻找左边的目标元素
        # 循环后i指向最左边的目标元素，j指向首个小于目标元素的元素
        else:
            j = m - 1
    return i


def binary_search_right_edge(nums, target):
    """"复用查找左边界的方法查找右边界"""
    # 调用查找左边界的方法
    j = binary_search_left_edge(nums, target + 1) - 1
    # 找不到目标元素时会出现两种情况
    # 1.目标元素大于列表中尾元素，循环后i指向len(nums),此时j = len(nums) - 1,即nums[j] != target:
    # 2.目标元素小于列表中首元素，循环后i指向0,此时j = -1，即j == - 1
    if j == -1 or nums[j] != target:
        return -1
    return j


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 3, 7, 8, 9]
    print(binary_search_right_edge(nums, 3))

7.将查找边界问题转化为查找元素

当我们搜索元素插入位置时

1.当数组中不存在目标元素时，循环后i指向首个大于目标元素target的元素，j指向首个小于目标元素target的元素

2.所以将查找左右边界问题转化为查找，目标元素target - 0.5和target + 0.5

第一次尝试：

def binary_search_left_edge(nums, target):
    """查找左边界"""
    return detail_left(nums, target - 0.5)


def detail_left(nums, target):
    # 创建左指针和右指针，分别指向列表首元素和尾元素,双闭区间
    i, j = 0, len(nums) - 1
    # 循环，直到i > j,即左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于target,则插入位置在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于target,则插入位置在区间[i, m - 1]中
        elif nums[m] > target:
            j = m - 1
    # 循环后，返回插入位置i
    return i


def binary_search_right_edge(nums, target):
    """查找右边界"""
    return detail_right(nums, target + 0.5)


def detail_right(nums, target):
    # 创建左指针和右指针，分别指向列表首元素和尾元素,双闭区间
    i, j = 0, len(nums) - 1
    # 循环，直到i > j,即左指针大于右指针
    while i <= j:
        # 计算中间元素的索引
        m = (i + j) // 2
        # 如果中间元素小于target,则插入位置在区间[m + 1, j]中
        if nums[m] < target:
            i = m + 1
        # 如果中间元素大于target,则插入位置在区间[i, m - 1]中
        elif nums[m] > target:
            j = m - 1
    # 循环后，返回插入位置i
    return j


if __name__ == '__main__':
    nums = [1, 2, 3, 3, 3, 6, 7, 8, 9]
    print(binary_search_left_edge(nums, 3))
    print(binary_search_right_edge(nums, 3))

海派派大星
关注
  • 24
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode分类解析：二分查找
西代零零发
08-14 5172
Leetcode分类解析：二分查找1.原始二分查找1.1 典型例题35-Search Insert Position (Medium): Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it w
二分查找算法总结
Summer_night_star的博客
02-18 7547
1 二分查找简介   二分查找也叫折半查找，是一种常见的查找方法，它将原本是线性时间提升到了对数时间范围，大大缩短了搜索时间。   二分查找必须具备两个条件，一是数列必须使用顺序存储结构（例如数组），二是数列必须有序。 2 二分查找的原理及实现   以升序数列为例，比较一个元素与数列中的中间位置的元素的大小，如果比中间位置的元素大，则继续在后半部分的数列中进行二分查找；如果比中间位置的元素小，则在数列的前半部分进行比较；如果相等，则找到了元素的位置。   每次比较的数列长度都会是之前数列的一半，直到找到相等
二分查找算法（递归+非递归）
热门推荐
天各一方的博客
10-10 1万+
二分算法步骤描述 前提：有序数组中查找关键词所在的位置 ① 首先确定整个查找区间的中间位置 mid = strat+(end-strat)/2 ② 用待查关键字key值与中间位置的关键字值进行比较； 若相等，则查找成功 若大于，则在后（右）半个区域继续进行折半查找 若小于，则在前（左）半个区域继续进行折半查找 ③ 对确定的缩小区域再按折半公式，重复上述步骤。 一、非递归二分查找算法...
【算法】手把手学会二分查找
Lin_Alpaca的博客
03-24 3873
二分查找算法的详细讲解，如果你还不懂二分，看这篇就对了✨✨
LeetCode算法题1：二分查找及扩展应用
Little_ant_的博客
01-25 4152
二分查找算法和扩展应用 第一个错误的版本 搜索插入位置
2种二分查找及2种优化方式
hacker00011000的专栏
09-06 1万+
题目1：经典算法—二分查找 折半查找的基本思想：减小查找序列的长度，分而治之的进行关键字的查找。该序列必须是有序的。 查找过程是：在有序表中，取中间的记录作为比较关键字，若给定值与中间记录的关键字相等，则查找成功；若给定的值小于中间记录的关键字，则在中间记录的左半区间继续查找；若给定值大于中间记录的关键字，则在中间记录的右半区间继续查找；不断重复这个过程，直到查找成功。否则查找失败实现：通常设置
二分查找算法及左右边界扩展
To Be Continue
07-31 2173
文章目录问题1：不重复数组中二分查找简洁版本：统一框架：问题2：二分查找并返回第一次出现(左边界)的位置简洁版本：统一框架：问题3：二分查找并返回最后一次出现(右边界)的位置简洁版本：统一框架： 二分查找算法的各种扩展 二分查找是一个非常简单的算法，思路简洁容易实现，但是面对诸如查找左边界、右边界问题时，总是容易不小心写错边界条件。 问题1：不重复数组中二分查找 在写二分查找代码时，一定要非常细心...
数组的二分查找
handsome_chuming的博客
03-12 1651
二分查找 解决什么问题？ 寻找数组中某一个元素 使用二分查找的前提条件是什么？ 数组的有序，且元素不重复 解决问题的思路是什么？ （1）设置两指针，low和high，分别指向数组的首部和尾部 （2）不断的将问题的规模缩小，直至low>high，循环结束（while）循环 （3）mid指针应该设为mid=low+（high-low）/2，其值实际上等于mid = low+high/2,，但low+high/2容易导致溢出 （4）问题的关键点：low、high指针的移动方法，当
算法刷题入门数据结构|二分查找
weixin_42575593的博客
12-11 2177
一.二分查找基础 1、二分查找介绍 二分查找(Binary search)也称折半查找，是一种效率较高的查找方法，时间复杂度。当对查数题目有时间复杂度要求是，首先就要考虑到二分查找。二分查找的思想很简单，属于分治策略的变种情况。但是，二分查找要求线性表中的记录必须是有序的集合，每次都通过跟区间的中间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间被缩小为 0，所以必须采用...
二分查找的5种实现--Java版
Cqy180的博客
08-08 4473
基础版，改动版，平衡版，java中的实现，对重复元素的处理（两种），力扣练习题链接，代码均以java实现
二分查找扩展
12-12
二分查找扩展 二分查找变型1--查找第一个值等于val的位置 二分查找变型2--查找最后一个值等于val的位置 二分查找变型3--查找最接近val并且小于val的位置 二分查找变型4--查找最接近val并且大于val的位置
php实现的二分查找算法示例
10-19
二分查找算法是一种在有序数组中寻找特定元素的搜索算法，其...此外，可以扩展到其他编程语言中的二分查找实现，以及在实际问题中如何优化和调整二分查找算法。通过实践和深入学习，可以更好地掌握这一高效的搜索算法。
C++二分查找算法实例
08-29
二分查找算法是一种在有序数组中寻找特定元素的搜索算法，它的核心思想是利用分治策略，通过不断缩小查找范围来提高效率。在C++中，我们可以使用...在实际编程中，可以根据具体需求对二分查找进行适当的修改和扩展。
PHP实现的二分查找算法实例分析
12-20
二分查找算法是一种高效的数据搜索方法，尤其适用于大型有序数组。这种算法利用了数组的有序性，通过不断缩小搜索范围来快速定位目标值。在PHP中实现二分查找，主要涉及以下几个关键步骤： 1. **初始化**：首先，...
使用javascipt---实现二分查找法
09-05
二分查找法，也称为折半查找法，是一种在有序数组中查找特定元素的搜索算法。它的基本思想是将数组分为两半，每次比较中间元素与目标值，根据比较结果缩小搜索范围，直到找到目标值或者搜索范围为空。在JavaScript中...
Python爬虫与MongoDB的完美结合
最新发布
weixin_52392194的博客
08-03 383
我们掌握了在Windows和Linux系统下安装MongoDB，设计适合爬虫存储数据的写入规范，并通过实际爬虫示例展示了如何将爬取到的数据存储到MongoDB中。此外，还进行了MongoDB性能优化，提高了数据存储和查询的效率。
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 394
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
python字符串数据容器练习（replace,split,count）
2301_79600015的博客
07-31 480
Python字符串是由一系列字符组成的数据类型。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它的内容。以下是关于Python字符串的一些重要知识点：1. 字符串的基本操作：拼接字符串：使用`+`运算符。重复字符串：使用`*`运算符。索引和切片：使用`[]`和`:`操作符访问字符串中的子串。长度：使用`len()`函数获取字符串长度。转换大小写：使用`upper()`和`lower()`方法。分割和连接：使用`split()`和`join()`方法。
Python入门知识点 10--闭包与装饰器
@网工小赵的博客
07-30 936
什么情况下会用到装饰器特性:在不修改源代码的基础上,给函数加功能。
二分查找scratch
07-28
在Scratch中实现二分查找算法是有一定挑战的，因为Scratch是一个可视化编程语言，主要用于教育和初学者。它的功能相对有限，没有内置的二分查找算法。 然而，我们可以通过自定义代码块来实现简化版的二分查找。下面是一个示例： 1. 创建两个变量，`low` 和 `high`，并将它们分别设置为列表的起始索引和终止索引。 2. 创建一个循环，直到 `low` 大于 `high` 为止： - 计算中间索引 `mid`（可以通过 `(low + high) / 2` 来获得）。 - 如果中间元素等于要查找的元素，则返回 `mid`。 - 如果中间元素大于要查找的元素，则将 `high` 更新为 `mid - 1`。 - 如果中间元素小于要查找的元素，则将 `low` 更新为 `mid + 1`。 3. 如果没有找到要查找的元素，则返回一个指定的值（例如-1）。 这只是一个简化的实现，你可以根据自己的需求进行修改和扩展。 请注意，在Scratch中实现复杂的算法可能会比较困难，因为它并不是为此而设计的。如果你想更深入地学习和实践算法，我建议尝试使用其他编程语言，如Python或Java，它们更适合处理这种类型的任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值