约瑟夫问题解析附C/C++代码——使用线段树解决

最新推荐文章于 2023-11-15 18:12:26 发布
最新推荐文章于 2023-11-15 18:12:26 发布
阅读量2.1k 收藏 13
点赞数 6
分类专栏： 算法 文章标签： 算法 数据结构 线段树 c++ 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aruewds/article/details/115429294
版权

目录

一、何为约瑟夫问题

  • 约瑟夫问题，也称约瑟夫斯置换。在计算机编程的算法中，类似问题又称为约瑟夫环。又称“丢手绢问题”。

  • 据说著名犹太历史学家 Josephus有过以下的故事：在罗马人占领乔塔帕特后，39 个犹太人与Josephus及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，由第1个人开始报数，每报数到第3人该人就必须自杀，然后再由下一个重新报数，直到所有人都自杀身亡为止。然而Josephus 和他的朋友并不想遵从。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了和，一开始要站在什么地方才能避免被处决？Josephus要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，于是逃过了这场死亡游戏。

  • 其实很好理解，n个人围成一圈，从第一个开始报数，第m个将被杀掉，最后剩下一个，其余人都将被杀掉。例如5个人，每次杀死第3个人，那么死亡的人数次序：3 -> 1 -> 5 -> 2 -> 4。每杀死一个人后，计数清零，并从下一个人开始循环计数直到满足3，如此往复。

1(1) 2(2) 3(3) 4(4) 5(5) --> 剩余队列编号 3 淘汰，对应原编号 3
1(1) 2(2) 3(4) 4(5) --> 剩余队列编号 1 淘汰，对应原编号 1
1(2) 2(4) 3(5) --> 剩余队列编号 3 淘汰，对应原编号 5
1(2) 2(4) --> 剩余队列编号 1 淘汰，对应原编号 2
1(4) --> 剩余队列编号 1 滔天，对应原编号 4

二、朴素法

  首先，既然人数（n）固定，那么每杀死一个人n减1，直到n = 0时就结束了，所以我们需要一个最外层的循环来判断是否结束。其次，杀死次序（m）也是固定的，定义一个变量j记录次数，当j = m时，杀死当前的人（打印出当前人的位置），j从头开始计数，标记已经死亡的人或删除死亡的人。
  朴素法思路很清晰，外循环判断是否所有人都死亡，内循环遍历所有存活的人，满足的元素被杀死，剩余人数减一。

2.1 朴素法-C语言

代码思路：

  1. 定义数组arr[n]记录所有存活的人，给每个人编号1~n，arr[i]即为编号，如果某人被杀死，arr[i] = -1。所以在遍历内循环时首先判断arr[i]是否为-1，否才执行。
  2. 总人数n，杀死次序m。
  3. 剩余人数num ，初始等于n，每杀死一个人num-1，直到num=0外循环结束，所有人被杀死（最后一个人活着），代码结束。
  4. 当前次序j，内循环每执行一次j+1，j = m时杀死人，j 重新赋值0。

代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    //约瑟夫问题
    int n = 41;//人数
    int m = 3;//第3个人杀死
    int num = 0;//已经死亡的人
    int j = 0;
    int* arr = (int*)malloc(sizeof(int) * n);
    if (arr == NULL)
        return 0;
    for (int i = 0; i < n; i++)//初始化数组arr
    {
        arr[i] = i + 1;
    }

    while (num < n)
    {
        for (int i = 0; i < n; i++)//遍历
        {
            if (arr[i] != -1)
            {
                j++;
                if (j == 3)//死亡
                {
                    printf("%d ", arr[i]);
                    arr[i] = -1;//标记死亡
                    j = 0;
                    num++;
                }
            }
        }
    }
    return 0;
    
}

2.2 朴素法-C++

代码思路：

  1. 总体思路和C语言法一致，不同在于使用STL容器vector存储各元素，可以使用erase()方法删除死亡的元素，省去判断是否死亡的判断，效率提高。
  2. 注意erase方法返回值是下一个元素的迭代器；并且it++需判断是否为空。

代码：

#include <iostream>
using namespace std;
#include <stdio.h>
#include <string>
#include <sstream>
#include <algorithm>
#include <map>
#include <vector>

int main()
{
    //约瑟夫问题
    int n = 41;//人数
    int m = 3;//第3个人杀死
    int j = 0;
    vector<int> arr(n);
    for (int i = 0; i < n; i++)
    {
        arr[i] = i + 1;
    }

    while (n > 0)
    {
        for (auto it = arr.begin(); it != arr.end(); )//遍历
        {
            j++;
            if (j == 3)//死亡
            {
                cout << *it << " ";
                it = arr.erase(it);//删除当前元素，返回下一个元的迭代器
                j = 0;
                n--;
            }
            else
            {
                if (!arr.empty())//判断是否为空，不可盲目++
                    it++;
                else
                    return 0;
            }

        } 
    }

    return 0;
    
}

三、线段树法

  显然直接暴力破解时间复杂度比较大，至少也是O(n)。那么有没有什么时间复杂度比较小的方式解决办法呢？切入正题，使用线段树解决约瑟夫问题。

3.1 何为线段树

  1. 线段树（Segment Tree）是一种二叉树，可视为树状数组的变种，1977 年由 Jon Louis Bentley 发明，用以存储区间或线段，并且允许快速查询结构内包含某一点的所有区间。线段树是一种用于维护区间信息的数据结构，可在O(logN)的时间复杂度内实现对数组的修改、查询。
  2. 线段树的单点查找非常迅速，而约瑟夫问题删除剩余队列第i个元素正好契合单点查找，所以采用线段树解决约瑟夫问题。

3.2 约瑟夫问题的线段树构建

（1）假设8个人，每次杀死第3个人。线段树构建方法：将一个区间化为为左右两个区间，然后递归处理，知道区间大小为1。
在这里插入图片描述

如上图，将8个人分区间递归建树，节点内的值是包含的叶子节点数目，区间[x:y]表示左子树和右子树的值，也可以认为是当前结点包含了区间内的所有值。可以看到，最后一排元素分别从左到右对应1~8数字，该特点和约瑟夫问题的剩余队列次序对应。

因此，对应线段树节点的表示方式：

typedef struct node_t
{
    int left;
    int right;
    int count;  //区间内的元素个数
}node_t;


（2）已经知道了线段树节点的建立，那么问题来了，如何用代码存储线段树？使用堆式建树，定义一个数组存储，各结点的数组下表如下图：
在这里插入图片描述
数组下表对应于树的层序遍历（广度优先搜素）。如果一个节点为a，那么它的左子节点为2a，右子节点为2a+1，父节点为a/2。因此可用移位操作符进行乘2操作加快速度。
代码如下：

#define L(a) ((a) << 1)       //2*a，该节点的左子节点的数组下表
#define R(a) (((a) << 1) + 1)   //2*a+1，该节点的右子节点的数组下表
#define MAXN 30001

node_t node[4 * MAXN];

注意：堆式建树的线段树的数组大小需要设为最大值的4倍。



（3）以上都是建树的初始化工作，理解了线段树的原理，就可以通过递归的方式建线段树了。

//以t为根节点，在区间[l, r]建立线段树
void build(int l, int r, int t)
{
    node[t].left = l;
    node[t].right = r;
    node[t].count = r - l + 1;//长度

    if (l == r)//左边等于右边，说明是同一节点，递归返回
        return;

    int mid = (l + r) / 2;
    build(l, mid, L(t));//节点的左子节点
    build(mid + 1, r, R(t));//节点的右子节点
}

建线段树过程，从根节点t出发，设定左子节点、右子节点和计数的值；当l==r时左右区间重合，说明已经是最后一个节点，递归返回。因为层序遍历，所以先递归左子树后递归右子树。

3.3 线段树的查询和修改

在前边我们已经建立了线段树，那么如何使用线段树解决约瑟夫问题呢？约瑟夫问题无非两步：第一，找到第m个要杀死的人，杀死并标记；第二，循环遍历至剩余一人。

3.3.1 删除结点（修改count）

  因为我们在定义线段树的节点时定义了count（即线段树包含叶子节点的个数），所以可以利用count和数组位序i对比来查询。当我们执行杀死步骤时，只要在遍历时沿途将相关节点的count减一，即标记该元素死亡。因为叶子节点count皆为1，每次杀死一个叶子节点，count=0，就可以标记死亡了。这样有利于后面计算剩余的人数。

//t是根节点，i是剩余队列编号，即删除的元素编号
int tdelete(int t, int i)
{
    node[t].count--;//每次递归进入时，当前节点元素少一

    if (node[t].left == node[t].right)//当前结点是最后一个,左和右都相等，找到了
    {
        printf("%d ", node[t].left);//左边和右边都一样
        return node[t].left;    
    }

    if (node[L(t)].count >= i)//左子节点数大于i，往左子树寻找
    {
        return tdelete(L(t), i);
    }
    else    //左子树人数不足，找右子树
    {
        return tdelete(R(t), i - node[L(t)].count);//因为此时:左子树count < i < 当前count，取i - 左子树count
    }
}

以上代码用于"删除"某个元素，即标记某个元素的死亡。基本思路是利用线段树叶子节点和剩余队列i的对应关系，通过count和i比较，递归到需要删除的元素位序i，将其删除。

栗子：杀死第三个人，tdelete(1, 3);

  • 第一次：根节点[1: 8]，count-1（7），左子节点count=4 > 3，递归左子节点tdelete(L(t), 3)。
  • 第二次：当前节点[1: 4]，count-1（3），左子节点count=2 < 3，此时递归右子节点，tdelete(R(t), 3 - 2)。
  • 第三次：当前节点[3: 4]，count-1（1），左子节点count=1 = 1，递归左子节点，tdelete(L(t), 1)。
  • 第四次：当前节点3，count-1（0），此时已经是叶子节点，node[t].left == node[t].right，打印出杀死的人3，返回值3。结束。

3.3.2 查询结点数（计算1~i的活人数）

  在前面删除结点的同时，将相关节点的count做了相应的修改，这时候为了计算下一次删除，需要计算1~i的活人数。计算方法，利用建树时分割区间的方法，同样地判断中间值和i的关系来确实是往左子树还是右子树遍历。如题，总的区间[1: 8]，要查找[1: 5]的活人数，直接[1: 4]的活人数count + 递归右子树即可。

//返回1~i的活人数
int get_count(int t, int i)
{
    if (node[t].right <= i)
    {
        return node[t].count;
    }

    int mid = (node[t].left + node[t].right) / 2;
    int s = 0;
    if (i > mid)
    {
        s += node[L(t)].count;//必然包括左子树的所有
        s += get_count(R(t), i);//再去右子树查找
    }
    else
    {
        s += get_count(L(t), i);
    }

    return s;
}

3.3.3 完整代码

  前两步是关键步骤，完成关键的操作：删除结点和遍历。之后，只要在主函数中：

  • 初始化数组和建立线段树
  • 循环遍历n次
  • 删除结点，并找到删除所在节点之前的活人数
  • 做一些特殊情况判断：j值超出总数count时，取余操作。因为可能遍历到后边时，后面元素不够了，需要从尾部返回头部。
#include <iostream>
using namespace std;
#include <stdio.h>
#include <string>
#include <sstream>
#include <algorithm>
#include <map>
#include <vector>
#include <string.h>

#define L(a) ((a) << 1)       //2*a，该节点的左子节点的数组下表
#define R(a) (((a) << 1) + 1)   //2*a+1，该节点的右子节点的数组下表
#define MAXN 30001

typedef struct node_t
{
    int left;
    int right;
    int count;  //区间内的元素个数
}node_t;

node_t node[4 * MAXN];

void init()
{
    memset(node, 0, sizeof(node));
}

//以t为根节点，在区间[l, r]建立线段树
void build(int l, int r, int t)
{
    node[t].left = l;
    node[t].right = r;
    node[t].count = r - l + 1;//长度

    if (l == r)//左边等于右边，说明是同一节点，递归返回
        return;

    int mid = (l + r) / 2;
    build(l, mid, L(t));//节点的左子节点
    build(mid + 1, r, R(t));//节点的右子节点
}


//t是根节点，i是剩余队列编号，即删除的元素编号
int tdelete(int t, int i)
{
    node[t].count--;//每次递归进入时，当前节点元素少一

    if (node[t].left == node[t].right)//当前结点是最后一个,左和右都相等，找到了
    {
        printf("%d ", node[t].left);//左边和右边都一样
        return node[t].left;    
    }

    if (node[L(t)].count >= i)//左子节点数大于i，往左子树寻找
    {
        return tdelete(L(t), i);
    }
    else    //左子树人数不足，找右子树
    {
        return tdelete(R(t), i - node[L(t)].count);//因为此时:左子树count < i < 当前count，取i - 左子树count
    }
}

//返回1~i的活人数
int get_count(int t, int i)
{
    if (node[t].right <= i)
    {
        return node[t].count;
    }

    int mid = (node[t].left + node[t].right) / 2;
    int s = 0;
    if (i > mid)
    {
        s += node[L(t)].count;//必然包括左子树的所有
        s += get_count(R(t), i);//再去右子树查找
    }
    else
    {
        s += get_count(L(t), i);
    }

    return s;
}


int main()
{
    int n = 41;
    int m = 3;

    init();
    build(1, n, 1);

    
    int j = 0;//剩余队列的虚拟编号
    for (int i = 1; i <= n; i++)
    {
        j += m;
        if (j > node[1].count)//大于最大长度，取余。一般用于遍历到后面时元素长度已经不够的时候
        {
            j %= node[1].count;
        }
        
        if (j == 0)//重新赋值，可能从头开始
        {
            j = node[1].count;
        }

        int k = tdelete(1, j);
        j = get_count(1, k);
    }

    return 0;
    
}

四、参考文章

暗夜无风
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C/C++ 约瑟夫环详解及实现源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-06 2584
约瑟夫环是一个数学问题，可以描述如下：n个人围成一个圈，从第一个人开始报数，报到m的人出列，然后从出列的下一个人重新开始报数，直到所有的人都出列。约瑟夫环问题是求出最后一个出列的人。确保输入的人数n和报数的数目m不会导致程序运行时间过长或内存占用过大。程序的输出结果是最后一个出列的人，需要根据实际需求进行适当的处理。输入的人数n必须大于等于报数的数目m，否则会出现数组越界的问题。确保输入的人数n和报数的数目m不会导致整数溢出。输入的人数n和报数的数目m必须是正整数。
约瑟夫环问题C++源代码
06-09
约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。 本代码采用循环链表的方式解决该问题。
C/C++经典算法——约瑟夫问题
热门推荐
青春无问西东 岁月自成芳华
07-26 11万+
C/C++经典算法——约瑟夫问题 什么是约瑟夫问题 一行代码解决约瑟夫问题！！！
约瑟夫问题(c++)
weixin_43534549的博客
02-02 2480
问题：N个人围成一圈，从第一个人开始报数，数到M的人出圈；再由下一个人开始报数（重头开始报数），数到M的人出圈；···输出依次出圈的人的编号。N、M由键盘输入。 分析：1，由于对于每个人只有出圈和没有出圈两种状态，因此可以用布尔型标志数组存储游戏过程中每个人的状态。不妨用true表示出圈，false表示没有出圈。 2，开始的时候，给标志数组赋初值为false，即全部在圈内。 3，模拟报数游戏的过程...
C++编程练习11--约瑟夫环问题
Heart912921的博客
11-22 2619
【代码】C++编程练习11--约瑟夫环问题。
C++ - 8月31日 - 两种方法解决约瑟夫环问题（数组、递归）
曾铎的博客
08-30 6281
约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3，...n分别表示）围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出圈，他的下一个人又从1开始报数，数到m的那个人又出圈；按照这个规律一直重复下去，知道剩余最后一个胜利者。..................
约瑟夫环问题用C++代码实现
10-04
8. 【题目】约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为1的人开始报数，数到k的那个人出列；他的下一个人又从1开始报数，数到k的那个人又...
EDA/PLD中的约瑟夫问题C语言代码实现过程
11-08
约瑟夫问题可以用循环单链表解决，循环单链表的特点是链表中最后一个节点的指针域不再是NULL，而是指向整个链表的第一个节点，从而使链表形成一个环。 　本题用到链表的建立，删除链表中的节点等知识： #include ...
数据结构-约瑟夫环问题（C/C++）-实验报告/课程设计
12-29
约瑟夫(Josephus)环问题: 设有n个人围成一圈，现从第s个人开始，拨顺时针方向从1开始报数，数到d的人退出圆圈，然后从退出圆圈的下一个人重新开始报数，数到d的人又退出國圈，依此重复下去，直到最后一个人出圈为止...
约瑟夫环C语言/C++代码代码
06-02
"约瑟夫环"（Josephus Problem...这个简单的程序使用递归方式解决了约瑟夫环问题，但实际的C++实现可能包括链表操作和循环结构，以适应更复杂的情况。通过理解和实践这些知识点，你可以更好地掌握编程基础和算法设计。
约瑟夫问题函数C++源码.zip
09-22
约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip约瑟夫问题函数C++源码.zip...
【C++】约瑟夫问题
m0_62953149的博客
01-03 1403
用指针操作数组实现：有 n 个人围成一圈，顺序排号。从第 1 个 人开始报数（从 1~3 报数），凡报到 3 的人退出圈子，问最后留下 的人原来排在第几号? 代码：#include< iostream> using namespace std; int main() { int n, num; int a[100]; int* p = a; cout << "n=? " << endl; cin >> n; for (int i = 0; i < n;
C++ 约瑟夫环(数组)
最新发布
weixin_74287172的博客
11-15 1067
设计并实现一个解决约瑟夫环问题的类Joseph。当需要解决一个n个人间隔为m的约瑟夫环问题，可以构建一个对象Joseph obj(n, m)，然后调用obj.simulate()输出模拟删除过程。输入为三个正整数n和m和k，空格分隔，分别代表编号长度和间隔长度和起始位置，编号长度n
约瑟夫问题 C++求解
MilkLeong的博客
02-02 1万+
约瑟夫环（Josephus）问题是由古罗马的史学家约瑟夫（Josephus）提出的，其表述方式有多种，较典型的一种是： 有ｎ只猴子，按顺时针方向围成一圈选大王（编号从１到ｎ），从第１号开始报数，一直数到ｍ，数到ｍ的猴子退出圈外，剩下的猴子再接着从1 开始报数。就这样，直到圈内只剩下一只猴子时，这个猴子就是猴王，编程求输入ｎ，ｍ后，输出最后猴王的编号。 解法一：数组求解 根据输入的n值确定数组的长度...
C++ 约瑟夫（Josephus）问题
ChanJose的博客
12-31 5951
一、题目：约瑟夫问题：n个人围成一桌，数到m的人出列   二、实现方法1: 每出列一个，就往前移动数组，用求余解决到尾问题 // 每出列一个，就往前移动数组 // 用求余解决到尾问题 #include &lt;iostream&gt; void JosePhus(int n, int m, int start) {     int i, *arr = new int[n]; // 动态分...
C++实现Josephus(约瑟夫环)问题。
weixin_59270606的博客
05-04 1万+
如何使用C++代码实现Josephus问题1、引言2、问题的分析与解决思路2.1：分析问题2.2：解决方案，数组实现2.3：编写程序3、完整代码 1、引言 有一段文本是这样的： 一群小孩 围成一圈，任意假定一个数m，从第一个小孩起，按顺时针方向数，每数到第m个小孩时，该小孩便离开。小孩不断离开，圈子不断缩小。最后，剩下的一个小孩便是胜利者。 Josephus问题就是：请问，究竟胜利者是第几个小孩？ OK，在此声明：对于屏幕前的，如果你是一个小白型选手，对于C++或任何一种语言诸如条件判断、循环、数组等知识
ffmpeg对rtmp的基本操作
weixin_30405421的博客
09-12 637
1、将文件当做直播送至live ffmpeg-re-ilocalFile.mp4-ccopy-fflvrtmp://server/live/streamName 2、将直播媒体保存至本地文件 ffmpeg-irtmp://server/live/st...
约瑟夫环的一种较为简单的数组实现方法（C++）
Fanxy_D的博客
10-24 1541
约瑟夫环是一个经典计算机问题 约瑟夫（Joseph）问题的一种描述是：编号为1,2,…,n的n个人按顺时针方向围坐一圈， 每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。 1.问题分析 ...
约瑟夫环问题(顺序表)——C++实现
liurry爱是不是不开口才珍贵
10-12 5582
#include #include #define MAXSIZE 100//人数上限 using namespace std; typedef int DataType; typedef struct{ DataType data[MAXSIZE];//存放编号的数组 int length; //人数 }SeqList,* PSeqList; int main(){ /*函数声明*/
解决用c++代码使用链表解决约瑟夫问题设计思路
06-06
好的，约瑟夫问题是一个经典的数学问题，可以通过使用链表来解决。下面是一个使用C++代码实现约瑟夫问题的设计思路： 1. 定义一个单向链表的结构体，包含两个成员变量：一个数据域和一个指向下一个节点的指针域。 ```c++ struct Node { int data; Node* next; }; ``` 2. 编写一个函数，用于创建一个含有n个节点的链表。在创建链表时，需要考虑每个节点的数据和下一个节点的指针。 ```c++ Node* createList(int n) { Node* head = new Node(); Node* p = head; for (int i = 1; i <= n; ++i) { Node* node = new Node(); node->data = i; p->next = node; p = p->next; } p->next = head->next; return head->next; } ``` 3. 编写一个函数，用于删除链表中的第m个节点。在删除节点时，需要修改前一个节点的指针，使其指向下一个节点。 ```c++ Node* removeNode(Node* head, int m) { Node* p = head; while (p->next != p) { for (int i = 1; i < m; ++i) { p = p->next; } Node* temp = p->next; p->next = temp->next; delete temp; p = p->next; } return p; } ``` 4. 在主函数中，调用上述函数，完成约瑟夫问题的求解。具体来说，我们可以先创建一个含有n个节点的链表，然后在循环中不断删除第m个节点，直到链表中只剩下一个节点为止。 ```c++ int main() { int n = 10; int m = 3; Node* head = createList(n); Node* result = removeNode(head, m); cout << "The last one is: " << result->data << endl; return 0; } ``` 这就是使用C++代码解决约瑟夫问题的基本思路。需要注意的是，在实际编写中，还需要考虑输入的合法性、内存的释放等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

暗夜无风

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

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

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

打赏作者

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

抵扣说明：

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

余额充值