数据结构之汉诺塔

最新推荐文章于 2023-05-01 14:07:00 发布
最新推荐文章于 2023-05-01 14:07:00 发布
阅读量1k 收藏 3
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuyingshudian/article/details/83046517
版权
  • 汉诺塔栈
#include <stdio.h>
#include <stack>


//递归实现
void hanoi_With_Recursion(int n, char x, char y, char z)
{
    if (n == 1)
    {
        printf("%d from %c to %c\n", n,x,z);
    }
    else
    {
        /* 将x 上编号1 至n-1 的圆盘移到y，z 作辅助塔*/
        hanoi_With_Recursion(n - 1, x, z, y);
        /* 将编号为n 的圆盘从x 移到z */
        printf("%d from %c to %c\n", n, x, z);
        /* 将y 上编号1 至n-1 的圆盘移到z，x 作辅助塔*/
        hanoi_With_Recursion(n - 1, y, x, z);
    }
}
int main()
{
    int n;
    scanf("%d", &n);
    printf("%d\n", (1 << n) - 1); /* 总次数*/
    hanoi_With_Recursion(n, 'A', 'B', 'C');
    return 0;
}

 

  • 汉诺塔队列
  • #include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>


#define FALSE 0
#define TRUE 1


char graph[10][43]={
{" ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \n"},
{" ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{" ? ? ? | ? ? ? ? ? ?| ? ? ? ? ? ?| ? ? ? \n"},
{"-----------------------------------------\n"},
};

typedef struct QNode {
int data; //存放数据
struct QNode *next;//存放直接后继的指针
} QNode, *QueuePtr;

typedef struct {  //辅助队列 ?广度优先扩展时用到
QueuePtr front;
QueuePtr rear;
} LinkQueue;

/* 初始化队列 */
int InitQueue(LinkQueue *Q)
{
/* 申请头结点空间，赋值给头/尾指针 */
Q->rear = Q->front = (QueuePtr)malloc(sizeof(QNode));
if (Q->front == NULL)
exit(-1);
Q->front->next = NULL;//头结点的next域
return TRUE;
}

/* 销毁队列 */
int DestroyQueue(LinkQueue *Q)
{
/* 整个链表(含头结点)依次释放
没有像链表、栈等借助 QNode *p, *q; 而直接借用了front和rear */
while (Q->front) { //若链表为空，则循环不执行
Q->rear = Q->front->next; //抓住链表的下一个结点
free(Q->front);
Q->front = Q->rear;
}

Q->rear = Q->front = NULL;
return TRUE;
}

/* 判断是否为空队列 */
int QueueEmpty(LinkQueue Q)
{
/* 判断front和rear指针是否相等 */
if (Q.front == Q.rear)
return TRUE;
else
return FALSE;
}

/* 元素入队列 */
int EnQueue(LinkQueue *Q, int e)
{
QueuePtr p;
p = (QueuePtr)malloc(sizeof(QNode));
if (p == NULL)
return FALSE;

p->data = e;
p->next = NULL;//新结点的next必为NULL
Q->rear->next = p;//接在当前队尾的后面
Q->rear = p; //指向新的队尾

return TRUE;
}

/* 元素出队列 */
int DeQueue(LinkQueue *Q, int *e)
{
QueuePtr p;
/* 空队列则返回 */
if (Q->front == Q->rear) //用Q->front->next==NULL也可以
return FALSE;

p = Q->front->next;//指向首元
Q->front->next = p->next;//front指向新首元，可能为NULL
/* 如果只有一个结点，则必须修改尾指针 */
if (Q->rear == p)
Q->rear = Q->front;
/* 返回数据并释放结点 */
*e = p->data;
free(p);
return TRUE;
}


void IsExist(int *state,int tnum,int num,LinkQueue &Q)
{ // 四个参数的意义: 状态记录数组，下一个状态值，当前状态值，状态值队列
if (state[tnum] == -1) // 如果下一个状态值未被分配:未取得(对应状态标记为-1:初始化标记),将该状态入队列
{
state[tnum] = num; // 修改下一个状态值为下标对应状态值数组的值(从-1变为上一状态值) ?(这里就包含了所求可行状态值之间的关系)
EnQueue(&Q, tnum); //元素入队列
}
}
/* --------- 图像输出函数集 ------------ */

void PrintGraph()
{
system("cls");
printf("过程演示：\n");
int i;
printf("\n");
for (i=0; i<10; i++)
printf("%s", graph[i]);
}

void InitGraph(int n)
{// 形成n对应的盘子叠加图形
int i,j,k;
for (i=0,j=8; i<n; i++,j--)
{
for(k=7-n+i; k<=7+n-i; k++)
graph[j][k]='@';
}
}

void Moveto(int from, int to, int size)//from to 只有0,1,2
{
//bool moved=false;//判断是否已移动
int i,j,k,m,slen;
int from1=from*13+7;
int to1=to*13+7;
for (i=2; i<9; i++)//找到起始层
if (graph[i][from1+1]=='@')//层数记录
 break;
 
for (j=2; j<=9; j++)//找到目标层数
if (graph[j][to1+1]=='@'||graph[j][to1+1]=='-')//层数记录
 {
 j--;
 break;
 }
// i 为当前层, j 为目标层

for(k=i-1; k>=0; k--)//上移
{
for (m=from1-size; m<=from1+size; m++){
graph[k][m]='@';
if (m==from1&&k>=1)
graph[k+1][m]='|';
else
graph[k+1][m]=' ';
}
PrintGraph();
}

slen=size*2+1;
if (from1<to1)//平移
for(k=from1; k<=to1; k++)//右移
{
for(m=k-size; m<k-size+slen; m++)
graph[0][m]='@';
graph[0][k-size-1]=' ';
PrintGraph();
}
else//左移
for(k=from1; k>=to1; k--)
{
for(m=k+size; m>k+size-slen; m--)
graph[0][m]='@';
graph[0][k+size+1]=' ';
PrintGraph();
}
//平移结束
/* 下移 */
for(k=1; k<=j; k++)
{
for (m=to1-size; m<=to1+size; m++){
graph[k][m]='@';
if (m==to1&&k>2)
graph[k-1][m]='|';
else
graph[k-1][m]=' ';
}
PrintGraph();
}

}

void Display(int **recd, int num, int len)//演示函数
{
int i,j,k=0;
int tmp[100][3];
//analysize recd
for(i=1; i<=num; i++)//compare with last one
{
 for (j=0; j<len; j++)
if (recd[i][j]!=recd[i-1][j])
{
tmp[k][0]=len-j;//变化的盘号
tmp[k][1]=recd[i-1][j];//变化的起始位置
tmp[k][2]=recd[i][j];//变化的终止位置
k++;
}
}
InitGraph(len);//根据层数进行初始化图像
PrintGraph();
i=0;
do
{
Moveto(tmp[i][1], tmp[i][2], tmp[i][0]);
i++;
}while(i<k);

printf("Over...");
getchar();
getchar();
}

/* ------------------------------------- */

/* 起始状态为0.....0 终止状态为2......2 */
int main()
{
/* -------------- 变量定义 ------------ */
int BRICKNUM;  //圆盘数
printf("请输入汉诺塔层数：");
scanf("%d",&BRICKNUM);

LinkQueue Q;
int i, j, k;
int n;
int num;
int temp_of_num;
int temp_of_add;
int num_of_state=1;//总状态数

for (int count=0; count<BRICKNUM; count++) //计算总状态数
num_of_state *= 3; // 每个盘子有3种状态(状态之间关联，有些没有用会被筛除掉)
 // 状态值数组表示了状态值之间的单向羁绊！状态值数组下标与状态值元素值是上下(前后)关系，当前状态值是以下一状态值为下标的状态元素的值
// 当前状态数组元素值是其上一个状态值
int *record_of_state = (int*)malloc(num_of_state*sizeof(int));  //每种状态的记录,-1代表未分配，否则为其父节点的下标 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?(总状态数为:num_of_state,状态分配状态值在相应数组中记录)
int *temp = (int*)malloc(BRICKNUM*sizeof(int)); // 定义存放n个盘子数，整型大小的存储空间
int *order_of_state = (int *)malloc(num_of_state*sizeof(int));//记录状态变化顺序

//此次汉诺塔问题借助三进制表示方法，0代表的是存在a柱子，1代表放在b柱子上，2代表放在c柱子上，位高的代表大盘，位低代表小盘，如? ? ? ? ?0000代表 ? ? ? ? ? ? ? 四个盘全部放在a柱子上


for (i = 0; i < num_of_state; i++)//初始化record_of_state
{
record_of_state[i] = -1; //-1状态表示未分配
}

InitQueue(&Q); // 初始化队列
num = 0; // num记录的是所有盘子元素状态序列对应的整数，可转化为一串0,1,2数字序列。
EnQueue(&Q, num); //状态1入栈，即0000(此时所有的盘子的状态都是0)
record_of_state[num] = -2; // 状态数的大小是根据n的取值来确定的(num代表一个状态的取值，num的最大值即为最大状态数)
/*
? ? ? ?这里是在出队列状态值的基础上,获取每一个盘子的状态(由整数得到一个数字序列)，在逐位来判断，确定下一状态值
? ? ? ?这里的规律:确定最底盘后(序列下标相对最小)，该位就一直不变
? ?*/

/* ?这里会筛选所需的状态值，以及他们的先后关系(每个状态值都进入了队列，有些被排除了，最后得到? ? ? ? 关键的状态值路径) ?*/
while (QueueEmpty(Q) == FALSE) //状态空间的生成（如果队列不为空，扩展状态空间）
{
DeQueue(&Q, &num); // 元素出队列，出队元素的值记录到了num中

n = num; // n获得的是当前盘子对应的状态序列整数(将整数整除3(三种摆放方式)得到序列：状态序列)


for (i = BRICKNUM - 1; i >= 0; i--) // 分解成三进制形式(从后往前存储，大盘子的状态再最前面=>整数的高位，对应数组下标越小)
{// 这里n个盘片，进行n次循环，temp对应是n个整型数据大小区间
temp[i] = n % 3; // 对应temp区间存储的是：n个盘子的状态序列
n /= 3;
}

if (temp[BRICKNUM - 1] == 0) //最后一位是0=>最上层盘子状态(该状态下:最小的盘子在a柱子上)
{ // 一个状态可以有多个子状态(关系记录在状态值数组中)
temp_of_num = num + 1; // 记录下一状态值(在当前出队列的状态值的基础上)
IsExist(record_of_state, temp_of_num,num, Q); //若下一状态值未被分配,将其入队列
temp_of_num = num + 2;
IsExist(record_of_state, temp_of_num,num, Q);


for (i = BRICKNUM - 2, temp_of_add = 3; i >= 0; i--)
{ //扫描当前状态值后续对应3进制的每一位
if (temp[i] == 1)
{
temp_of_num = num + temp_of_add;
IsExist(record_of_state, temp_of_num,num, Q);
break;
}
else if (temp[i] == 2)
{
temp_of_num = num - temp_of_add;
IsExist(record_of_state, temp_of_num,num, Q);
break;
}
temp_of_add *= 3;
}
}
else if (temp[BRICKNUM - 1] == 1) //最后一位是1(该种状态下:最小的盘子在b柱子上)
{
temp_of_num = num - 1;
IsExist(record_of_state, temp_of_num,num, Q);

temp_of_num = num + 1;
IsExist(record_of_state, temp_of_num,num, Q);

for (i = BRICKNUM - 2, temp_of_add = 3; i >= 0; i--)
{
if (temp[i] == 0)
{
temp_of_num = num + temp_of_add * 2;
IsExist(record_of_state, temp_of_num,num, Q);
break;
}
else if (temp[i] == 2)
{
temp_of_num = num - temp_of_add * 2;
IsExist(record_of_state, temp_of_num,num, Q);
break;
}
temp_of_add *= 3;
}
}
else // 该状态下:最小的盘子在c柱子上
{
temp_of_num = num - 2;
IsExist(record_of_state, temp_of_num,num, Q);

temp_of_num = num - 1;
IsExist(record_of_state, temp_of_num,num, Q);

for (i = BRICKNUM - 2, temp_of_add = 3; i >= 0; i--)
{
if (temp[i] == 0)
{
temp_of_num = num + temp_of_add;
IsExist(record_of_state, temp_of_num,num, Q);
break;
}
else if (temp[i] == 1)
{
temp_of_num = num - temp_of_add;
IsExist(record_of_state, temp_of_num,num, Q);
break;
}
temp_of_add *= 3;
}
}
}

/*
1: 如何完成的所有状态值无序入队列
2: 前后结点（状态值之间联系）查找，筛选的算法
*/

 /* ?order_of_state 数组装载的是筛选的路径中入队的状态值,虽然所有的状态值都入过对列，但从中选择出了最短需要路径*/
num = num_of_state - 1; // 状态值数组最大下标
// 初始record_of_state数组的值都被赋值为-1，如果要入队列就将其值赋值为上一状态值的大小
i = 0; // 从后往前遍历状态值数组:如果当前状态值入过队列,则其值为上一状态值
while (record_of_state[num] != -2) // 跳出口为第一个状态值0...0，其对应状态值数组值为-2.它是作为起点单独处理的
{
order_of_state[i] = num; // 这里记录着入过队列:即为分配过的状态值元素下标?
num = record_of_state[num]; // num记录上一状态值，也即上上状态值对应下标 (应该可以将值与下标转化为相差为1的关系)
i++;
}
order_of_state[i] = num; // 在num=0时并没有装入order_of_state就跳出了循环

int mycount=0;
int **recd = (int **)malloc((i+1)*sizeof(int *));//记录状态变化顺序
for (j=0; j<=i; j++)
recd[j] = (int *)malloc(BRICKNUM*sizeof(int));
// int **recd= new int[i][BRICKNUM];//记录状态变化，以便图像演示使用
for (j=i; j>=0; j--)
{
n = order_of_state[j];
for (k = BRICKNUM - 1; k >= 0; k--) //分解成三进制形式
{
temp[k] = n % 3;
n /= 3;
}
memcpy(recd[mycount], temp, BRICKNUM*sizeof(int));
mycount++;
for (k = 0; k < BRICKNUM; k++)
printf("%d", temp[k]);
printf("\n");
}
getchar();
getchar();
//输出演示
if(BRICKNUM!=0)
 Display(recd, i, BRICKNUM);
//释放变量
free(temp);
free(record_of_state);
free(order_of_state);
for (k=0; k<=i; k++)
free(recd[k]);
free(recd);
getchar();
return 0;
}

     

流萤数点
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
2021-07-27：给定一个数组arr，长度为N，arr中的值只有1，2，3三种。arr[i] == 1，代表汉诺塔问题中，从上往下第i个圆盘目前在左；arr[i] == 2，代表汉诺塔问题中，从上
福大大架构师每日一题
07-27 3349
2021-07-27：给定一个数组arr，长度为N，arr中的值只有1，2，3三种。arr[i] == 1，代表汉诺塔问题中，从上往下第i个圆盘目前在左；arr[i] == 2，代表汉诺塔问题中，从上往下第i个圆盘目前在中；arr[i] == 3，代表汉诺塔问题中，从上往下第i个圆盘目前在右。那么arr整体就代表汉诺塔游戏过程中的一个状况。如果这个状况不是汉诺塔最优解运动过程中的状况，返回-1。如果这个状况是汉诺塔最优解运动过程中的状况，返回它是第几个状况。 福大大 答案2021-07-27： 1-7的汉诺
汉诺塔（内部+伪图形）
Tong_jy的博客
01-26 2987
1.1问题描述： 假设有三个分别命名为A,B,C的塔座，在塔座A上插有n个直径大小各不相同的圆盘，大的在下，小的在上，且从小到大编号为1,2,3…。现要求将塔座A上的n个圆盘移到塔座C上并仍按同样的顺序叠排，圆盘移动时必须遵守以下规则： （1）每次只能移动一个圆盘 （2）圆盘可以插在A,B,C中任一塔上 （3）任何时刻都不能将一个较大的圆盘压在较小的圆盘之上1.2题目要求： （1）基本解：
【数据结构】汉诺塔问题（丰富图解）
℉f的博客
05-01 3387
经典汉诺塔问题，丰富图解，助你理解。
汉诺塔实现（含数组修改）Implement of hanoi
人生如路
04-07 1302
汉诺塔的实现，包含伪代码，以及输出流程版本和修改数组版本。
《数据结构和算法》之汉诺塔
阿黄啦啦
03-11 2609
一，问题描述：        法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔。不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片：一次只移动一片，不管在哪根针上，小片必须在大片上面。僧侣们预言，当所有的金片都从梵天
JAVA数据结构之汉诺塔代码实例
08-26
主要介绍了JAVA数据结构之汉诺塔，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
hannuota.rar_数据结构_汉诺塔
09-19
对于汉诺塔，大家一点不陌生，这是我数据结构的一个作业，里面讲的很详细
数据结构实验报告汉诺塔.doc
07-11
实验报告书 课程名： 数据结构 题 目： 汉诺塔 班 级： 学 号： 姓 名： 一、目的与要求 1）掌握栈与队列的数据类型描述及特点； 2）熟练掌握栈的顺序和链式存储存表示与基本算法的实现； 3）掌握队列的链式存储表示...
java数据结构和算法学习之汉诺塔示例
09-04
主要介绍了java数据结构和算法中的汉诺塔示例,需要的朋友可以参考下
数据结构 汉诺塔问题课程设计.docx
12-05
数据结构 汉诺塔问题课程设计
数据结构设计--汉诺塔
12-27
完整的数据结构设计报告 有封面，任务书，前言，需求分析，测试，小结，参考文献，等。
数据结构与算法：汉诺塔
trustF的博客
08-06 1389
汉诺塔问题是一个经典的递归例子。这个问题是将指定个数而大小互不相同的盘子从一个塔移动到另一个塔上，移动时要遵循以下规则： n个盘子从上到下依次标记为1,2,3,...,n,而三个塔标记为A、B、C。 任何时候盘子都不能放在比它小的盘子的上方。 初始状态时，所有的盘子都放在塔A上。 每次只能移动一个盘子，并且这个盘子必须在塔顶的位置。 这个问题的目标是借助塔C把所有的盘子从塔A移到塔B。例如...
算法:汉诺塔(栈的递归调用)-数据结构(9)
健景的博客
05-18 1020
一、问题描述 参见网上汉诺塔的玩法。书上P54-58。解析：栈的递归调用其实是函数参数是以栈的形式push进栈来调用函数的，因此递归是用到栈的，只是没有很形象而已。解决汉塔的思路是这样的：设n为汉诺塔的盘子数，xyz是三根柱子。要让z有n个盘子的做法，先是将x的n-1个盘子移到y，然后将第n个盘子移到z，就这样的思路进行下去，最后就可以把汉诺塔的问题解决了。 二、算法实现 int c = 0
数据结构与算法_汉诺塔
翱翔的魁魁
12-23 2160
汉诺塔 相传在古印度圣庙中，有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置64个金盘(如图)。游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。 编写语言Swift func hanno(num: Int, columnFrom: String, columnTemp: String
利用栈实现汉诺塔（Tower of Hanoi）
alm_of_csdn的博客
04-29 4015
利用栈实现汉诺塔（Tower of Hanoi）
数据结构---汉诺塔
sjtu_chenchen的专栏
04-28 1278
/*汉诺塔：A座有n个盘子，下面直径比上面大，要借助C座，将n个盘子移到B上，移动过程中大盘子一定在小盘子下面*/ package pack;public class Main { static int n = 10; public static void main(String[] args) { han(n,'A','B','C'); //将n个盘子借助C，
《数据结构与课程设计》大作业 汉诺塔问题
weixin_51012937的博客
07-25 2636
《数据结构与课程设计》 大作业 项目名称汉诺塔问题的递归和非递归实现 学院信息与通信工程学院 年级专业20级智能科学与技术 姓名孙成 学号20203101694 完成时间2021-6-5 指导教师周铁老师 开 课 时 间2020至202...
算法设计分析 ——汉诺塔（超详细）
我的博客
11-13 2633
汉诺塔问题 给定一个由n个圆盘组成的塔，这些圆盘按照大小递减的方式套在第一根桩柱上。现要将整个塔移动到另一根桩柱上，每次只能移动一个圆盘，且较大的圆盘在移动过程中不能放置在较小的圆盘上面。 输入格式: 输入由四行： 第一行是圆盘数量n(1<=n<=10); 第二行到第四行分别是三根桩柱的名字(字符串)，n个盘子套在第一根桩柱上。 输出格式: 输出移动步骤，每行输出一步。 输入样例: 在这里给出一组输入。例如： 2 a b c 输出样例: 在这里给出相应的输出。例如： a->b
麻瓜蛋蛋的汉诺塔程序
qq_44002133的博客
12-12 85
# include <stdio.h> void hannuota(int n, char A, char B, char C) { /* 如果是1个盘子 直接将A柱子上的盘子从A移到C 否则 先将A柱子上的n-1个盘子借助C移到B 直接将A柱子上的盘子从A移到C 最后将B柱子上的n-1个盘子借助A移到C */ if (1 == n) { printf("将编号为%d的盘子直接从%c柱子移到%c柱子\n", n, A, C); } else { hannu
数据结构汉诺塔程序设计
最新发布
06-04
汉诺塔问题是经典的递归问题，其目的是将一个塔A上的圆盘按照从大到小的顺序移动到另一个塔C上，期间可以借助另一个塔B。移动过程中要满足以下三个规则： 1. 每次只能移动一个圆盘； 2. 大圆盘不能放在小圆盘上面； 3. 借助的塔只能用一次。 这个问题可以使用递归算法解决，具体实现过程可以参考以下伪代码： ``` hanoi(n, A, B, C)： 如果n==1: 直接将A上的圆盘移动到C上 否则： 将A上的n-1个圆盘借助C移动到B上 将A上的最后一个圆盘移动到C上 将B上的n-1个圆盘借助A移动到C上 ``` 其中n表示圆盘的数量，A、B、C分别代表三个塔。在递归调用中，通过不断缩小规模，最终实现了将n个圆盘从A移动到C的过程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

流萤数点

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

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

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

打赏作者

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

抵扣说明：

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

余额充值