《啊哈算法》第四章 万能的搜索

最新推荐文章于 2022-04-26 21:32:29 发布
最新推荐文章于 2022-04-26 21:32:29 发布
阅读量3.4k 收藏 14
点赞数 2
分类专栏： 啊哈算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinchaoji_/article/details/51264007
版权

参考：《啊哈算法》

这里的搜索与图的遍历要区分开，这里只是对数的搜索进行尝试，常用于地图搜索什么，查找是否通路什么的。

深度优先搜索

问题
求出数字123的全排列

额，先来暴力一个；

#include <cstdio>
int main() {
    for(int i=1; i<=3; i++) {
        for(int j=1; j<=3; j++) {
            for(int k=1; k<=3; k++) {
                if(i!=j&&i!=k&&j!=k) {
                    printf("%d %d %d \n",i,j,k);
                }
            }
        }
    }
    return 0;
}

下面展示深搜bfs

#include <cstdio>
int a[4],book[4];
void dfs(int step) {
    if(step==4) {
        for(int i=1; i<=3; i++) {
            printf("%d ",a[i]);
        }
        printf("\n");
        return ;
    }
    for(int i=1; i<=3; i++) {
        if(book[i]==0) {
            a[step]=i;
            book[i]=1;
            dfs(step+1);
            book[i]=0;
        }
    }
}
int main() {
    dfs(1);
    return 0;
}

dfs公式

void dfs(int step)
{
    判断边界
    尝试每一种可能 for(int i=1;i<=n;i++)//尝试每一种可能意味深长呀
    {
        继续下一步 dfs(step+1);
    }
    返回
}
嗯，我是体会了很长一段时间才体会到尝试每一种可能是什么意思，。，。，人笨呀，。，。每一个循环都不会浪费，到底后，进行返回。大分支结束大返回，回收发出去的牌，小分支结束小返回，回收发出去的牌。（递归的特点）

问题

假设你的手中有1-9九个数字，分别放到【】中，使得【】【】【】+【】【】【】=【】【】【】成立。

分析，这就是先将1-9进行全排列，再进行筛选使得条件成立的情况就可以了，暴力虽然笨拙，但是也能实现目标

#include <cstdio>
int a[10],book[10];
void dfs(int step) {
    if(step==10) {
        if(a[1]*100+a[2]*10+a[3]+a[4]*100+a[5]*10+a[6]==a[7]*100+a[8]*10+a[9]) {
            printf("%d%d%d %d%d%d %d%d%d\n",a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]);
            //这个是返回最近一次调用dfs的关键语句
        }
        return ;
    }
    for(int i=1; i<=9; i++) {
        if(book[i]==0) {
            a[step]=i;
            book[i]=1;
            dfs(step+1);//不能写成step++
            book[i]=0;//一定要注意回收
        }
    }
}
int main() {
    dfs(1);
    return 0;
}

问题

A被困在迷宫中，求解救
输入迷宫的大小并输入迷宫，0为空地，1为障碍物
再输入出发解救位置，输入A的位置，输出最小路径

code
简单的分析：深度优先搜索的实质是一次次进行尝试，最具代表性的引用就是数字的全排列莫属了，这里也是一样，不断地进行尝试，有可能到达目的地的路径不止一条，因此dfs能够帮助我们找到所有通向目的地的路径，记录下步长，就能查找出最短路径了。（所谓的尝试就是同样的初始条件下进行不同的选择，因此在各种情况执行后，还是需要恢复到各种初始状态，所以每次的回收很重要，每次的return至最近一次调用也是很关键）。dfs应该是能想象成兵分XX路，再兵分XX路，他们的目的地是相同的。

#include <cstdio>
int c[51][51],book[51][51];
int next[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};//这里一定要和数学上的坐标进行区分，x,y分别代表行和列
int a,b;
int min=999999999;
int startx,starty,p,q;
void dfs(int x,int y,int step) {
    int tx,ty;
    if(x==p&&y==q) {
        if(step<min) {
            min=step;
        }
        return ;//判断边界的返回不能丢
    }
    for(int i=0; i<=3; i++) {
        tx=x+next[i][0];
        ty=y+next[i][1];
        if(tx<1||tx>a||ty<1||ty>b) {//判断是否越界
            continue;
        }
        if(book[tx][ty]==0&&c[tx][ty]==0) {
            book[tx][ty]=1;
            dfs(tx,ty,step+1);
            book[tx][ty]=0;//收回不能丢
        }
    }
}
int main() {
    scanf("%d%d",&a,&b);
    for(int i=1; i<=a; i++) {
        for(int j=1; j<=b; j++) {
            scanf("%d",&c[i][j]);
        }
    }
    scanf("%d%d%d%d",&startx,&starty,&p,&q);
    book[startx][starty]=1;//这里就和全排列有点不一样，因为这里进去之后就要发生改变，而全排列进去之后不改变
    dfs(startx,starty,0);
    printf("%d\n",min);
    return 0;
}
测试数据
5 4
0 0 1 0 
0 0 0 0
0 0 1 0
0 1 0 0
0 0 0 1
1 1 4 3

广度优先搜索

同样是对四周进行扩展，只是bfs是所有能扩展的点进入队列，不像深搜，不到最后不回头

问题

解决上一个问题

简单分析：与dfs不同，dfs的终止条件是到达目的地就退出，结束搜索，当然人家的搜索方法也是决定了第一次到达地步长最短了。因此，bfs同样也是能够找出多条到达目的地的路径，但是第一次到达的时候用的步长一定是最短的。bfs应该是能够想象成一个小圆点不断的向四周膨胀至结束位置的过程。

#include <cstdio>
#define N 51
int c[N][N],book[N][N];//保存地图和标记数组，一般标记数组和地图一一对应
int next[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};//这个探索方向是很有味道的
typedef struct Que {
    int x;
    int y;
    int step;
};//用一个结构体模拟链表进行存放，出队和入队
int main() {
    Que que[2501];//为什么要开这么大的数组？最坏情况是走完地图上的所有点才到达目的地，但是一般不会出现这种情况，但是我们也无法知道每次究竟要扩展到哪里（多少步，只能概全了）
    int a,b;
    scanf("%d%d",&a,&b);//输入地图大小
    for(int i=1; i<=a; i++) {
        for(int j=1; j<=b; j++) {
            scanf("%d",&c[i][j]);//输入地图
        }
    }
    int startx,starty,p,q;
    scanf("%d%d%d%d",&startx,&starty,&p,&q);//输入起始地址和目标地址
    int head=1;
    int tail=1;//初始链表
    book[head][head]=1;//将出发地址标记，表示已经访问过了
    que[head].x=startx;
    que[head].y=starty;//出发地址入队
    que[head].step=0;
    tail++;//与我们一般情况对应，一般是tail指向队尾的下一位置方便添加
    int flag=0;
    while(head<tail) {
        for(int i=0; i<=3; i++) {//在队列的ead处的点四个相邻方向扩展
            int tx,ty;
            tx=que[head].x+next[i][0];
            ty=que[head].y+next[i][1];
            if(tx<1||tx>a||ty<1||ty>b) {//判断是否越界，若不合条件即认为已经到了边界，马上退出执行下一次循环
                continue;
            }
            if(c[tx][ty]==0&&book[tx][ty]==0) {//判断扩展到的点是否符合条件
                que[tail].x=tx;
                que[tail].y=ty;//符合条件则入队
                book[tx][ty]=1;//并标记已经访问过了
                que[tail].step=que[head].step+1;//扩展步数等于head(父步数）+1;
                tail++;//用完再向后移动，方便下一次的入队
            }
            if(tx==p&&ty==q) {//到达目的地后退出循环，因为是bfs，第一次到达目的地所用步数应该是最少的，不需要尝试，直接退出
                flag=1;
                break;
            }
        }
        if(flag) {
            break;//两个退出是因为有两个循环，而我们是到达目的地后一次性退出所有循环
        }
        head++;//每一个head扩展四个方向上的点，（四个点），然后再向下一个点移动
    }
    printf("%d\n",que[tail-1].step);//tail++每次都执行了的，因此收尾时tail仍是指向的队尾的下一位置，-1进行提前
    return 0;
}

炸弹人

问题

给出一个二维数组，并用字符填充，其中.G#分别代表空地，敌人，不能炸坏的墙。请问在哪里放置炸弹才能消灭最多的敌人。

简单暴力：循环遍历每一个点，对这个点的攻击范围内的敌人进行统计记录，并随时更新。（暴力鲁棒性不足，因为这样的话就是默认炸弹是可以放在任何一块空地上的，但是事实并非如此，即有些空地是不能放置炸弹的，即有可能某块或几块空地被墙包围着，根本就无法进入空地放置炸弹）

#include <cstdio>
#define N 20
char a[N][N];//创建二维数组准备填充数据
int main() {
    int b,c;
    scanf("%d%d",&b,&c);//输入准备创建地图的规模
    for (int i=0; i<b; i++) {
        scanf("%s",a[i]);//创建地图，按行读入
    }
    int max=0;
    int x,y;
    int p,q;
    for(int i=0; i<b; i++) {
        for(int j=0; j<c; j++) {//二重循环遍历地图，这样是通过每一个都进行遍历，并且统计每个点的消灭敌人数，更新
            if(a[i][j]=='.') {//判断空地然后开始搜索
                int  sum=0;
                x=i;
                y=j;
                while(a[x][y]!='#') {//遇到墙就停止搜索
                    if(a[x][y]=='G') {
                        sum++;
                    }
                    x--;//向上搜索
                    if(x<0||x>=b) {//判断边界
                        break;
                    }
                }
                x=i;
                y=j;
                while(a[x][y]!='#') {
                    if(a[x][y]=='G') {
                        sum++;
                    }
                    x++;//向下搜索
                    if(x<0||x>=b) {
                        break;
                    }
                }
                x=i;
                y=j;
                while(a[x][y]!='#') {
                    if(a[x][y]=='G') {
                        sum++;
                    }
                    y--;//向右搜索
                    if(y<0||y>=c) {
                        break;
                    }
                }
                x=i;
                y=j;
                while(a[x][y]!='#') {
                    if(a[x][y]=='G') {
                        sum++;
                    }
                    y++;//向左搜索
                    if(y<0||y>=c) {
                        break;
                    }
                }
                if(sum>max) {//更新max
                    max=sum;
                    p=i;
                    q=j;
                }
            }
        }
    }
    printf("在(%d,%d)位置最多能消灭%d\n",p,q,max);
    return 0;
}
测试数据
13 13
#############
#GG.GGG#GGG.#
###.#G#G#G#G#
#.......#..G#
#G#.###.#G#G#
#GG.GGG.#.GG#
#G#.#G#.#.###
##G...G.....#
#G#.#G###.#G#
#...G#GGG.GG#
#G#.#G#G#.#G#
#GG.GGG#G.GG#
#############

针对鲁棒性不强有以下解决方案，先要判断出能到达哪些空地，然后再对该块空地四周搜索统计敌人数量，但是怎样判断能否到达空地尼？嗯，bfs或者dfs。用bfs或dfs来枚举所有小人可以到达的点，然后在这些可以到达的点上分别统计可以消灭的敌人数

dfs展示
#include<cstdio>
#define N 21
int book[N][N];
int next[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};
char maps[N][N];
int max=0;
int p,q;
int a,b,startx,starty;
int getnum(int i,int j) {
    int sum=0;
    int x;
    int y;
    x=i;
    y=j;
    while(maps[x][y]!='#') {//遇到墙就停止搜索
        if(maps[x][y]=='G') {
            sum++;
        }
        x--;//向上搜索
        if(x<0||x>=a) {//判断边界
            break;
        }
    }
    x=i;
    y=j;
    while(maps[x][y]!='#') {
        if(maps[x][y]=='G') {
            sum++;
        }
        x++;//向下搜索
        if(x<0||x>=a) {
            break;
        }
    }
    x=i;
    y=j;
    while(maps[x][y]!='#') {
        if(maps[x][y]=='G') {
            sum++;
        }
        y--;//向右搜索
        if(y<0||y>=b) {
            break;
        }
    }
    x=i;
    y=j;
    while(maps[x][y]!='#') {
        if(maps[x][y]=='G') {
            sum++;
        }
        y++;//向左搜索
        if(y<0||y>=b) {
            break;
        }
    }
    return sum;
}
void dfs(int x,int y) {

    int sum=getnum(x,y);
    if(sum>max) {
        max=sum;
        p=x;
        q=y;
    }
    int tx,ty;
    for(int i=0; i<=3; i++) {
        tx=x+next[i][0];
        ty=y+next[i][1];
        if(tx<0||tx>a-1||ty<0||ty>b-1) {
            continue;
        }
        if(maps[tx][ty]=='.'&&book[tx][ty]==0) {
            book[tx][ty]=1;
            dfs(tx,ty);
        }
    }

}
int main() {

    scanf("%d%d%d%d",&a,&b,&startx,&starty);
    for(int i=0; i<a; i++) {
        scanf("%s",maps[i]);
    }
    dfs(startx,starty);
    printf("在(%d,%d)位置最多能消灭%d\n",p,q,max);
    return 0;
}

测试：

13 13 3 3
#############
#GG.GGG#GGG.#
###.#G#G#G#G#
#.......#..G#
#G#.###.#G#G#
#GG.GGG.#.GG#
#G#.#G#.#.#.#
##G...G.....#
#G#.#G###.#G#
#...G#GGG.GG#
#G#.#G#G#.#G#
#GG.GGG#G.GG#
#############

（与第一个暴力的数据有改动）

bfs展示
#include <cstdio>
#define N 21
char maps[N][N];
int book[N][N];
int next[4][2]= {{0,1},{1,0},{0,-1},{-1,0}};
int max=0;
int a,b,startx,starty;
typedef struct Que {
    int x;
    int y;
};
int getnum(int i,int j) {
    int sum=0;
    int x;
    int y;
    x=i;
    y=j;
    while(maps[x][y]!='#') {//遇到墙就停止搜索
        if(maps[x][y]=='G') {
            sum++;
        }
        x--;//向上搜索
        if(x<0||x>=a) {//判断边界
            break;
        }
    }
    x=i;
    y=j;
    while(maps[x][y]!='#') {
        if(maps[x][y]=='G') {
            sum++;
        }
        x++;//向下搜索
        if(x<0||x>=a) {
            break;
        }
    }
    x=i;
    y=j;
    while(maps[x][y]!='#') {
        if(maps[x][y]=='G') {
            sum++;
        }
        y--;//向右搜索
        if(y<0||y>=b) {
            break;
        }
    }
    x=i;
    y=j;
    while(maps[x][y]!='#') {
        if(maps[x][y]=='G') {
            sum++;
        }
        y++;//向左搜索
        if(y<0||y>=b) {
            break;
        }
    }
    return sum;
}
int main() {
    Que que[401];
    scanf("%d%d%d%d",&a,&b,&startx,&starty);
    for(int i=0; i<a; i++) {
        scanf("%s",maps[i]);
    }
    int head=0;
    int tail=0;
    book[startx][starty]=1;
    que[head].x=startx;
    que[head].y=starty;
    tail++;
    int tx,ty;

    int p,q;
    while(head<tail) {
        //将所有能到的点入队，再从头到尾统计比较
        int sum=getnum(que[head].x,que[head].y);
        if(sum>max) {
            max=sum;
            p=que[head].x;
            q=que[head].y;
        }
        for(int i=0; i<=3; i++) {
            tx=que[head].x+next[i][0];
            ty=que[head].y+next[i][1];
            if(tx<1||tx>=a||ty<1||ty>=b) {
                continue;
            }
            if(maps[tx][ty]=='.'&&book[tx][ty]==0) {
                book[tx][ty]=1;
                que[tail].x=tx;
                que[tail].y=ty;
                tail++;
            }
        }
        head++;
    }
    printf("在(%d,%d)位置最多能消灭%d\n",p,q,max);
    return 0;
}

测试：

13 13 3 3
#############
#GG.GGG#GGG.#
###.#G#G#G#G#
#.......#..G#
#G#.###.#G#G#
#GG.GGG.#.GG#
#G#.#G#.#.#.#
##G...G.....#
#G#.#G###.#G#
#...G#GGG.GG#
#G#.#G#G#.#G#
#GG.GGG#G.GG#
#############

总结：

对于一维数组的搜索，二维数组的搜索都是很有特点的，不管是bfs还是dfs，，，，不过我发现bfs最好掌握和理解

飘过的小熊
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
啊哈算法第四章 万能的搜索
seineo
04-22 409
从这一章开始就真的步入对我而言全新的算法世界了（因为排序、枚举在上学期还是接触过的，而栈、队列在这学期我看的C++Primer和老师教的Java课里也有所涉及） 一、深度优先搜索（Depth First Search） 首先作者用上章遗留的全排列问题作为引例为我们介绍了DFS是啥东西。 题目1：输入一个数n 请输出1~n的全排列。 当然我们可以用上一章的枚举来做，并且用一个book[10]...
啊哈算法---快速排序（C语言）
m0_54129816的博客
06-24 5210
文章目录前言一、快速排序是什么？实现原理二1.![在这里插入图片描述](https://img-blog.csdnimg.cn/20210624142203649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzU0MTI5ODE2,size_16,color_FFFFFF,t_70#pic_center)快速排序代码块 前言 冒泡排序在啊
《啊哈！算法》第4章 万能的搜索
weixin_30606669的博客
06-22 127
第5节 宝岛探险 利用广度优先搜索实现 其中可以不用开辟visit变量，直接用将本身的值改为-1，然后判断即可 注意输入数据时周围加了一层-1，作为边界 广度优先搜索 利用深度优先搜索实现，注意下面的方法是将搜索到的点着成-1的颜色 深度优先搜索 注意如果n和m比较大的话，建议用广度优先搜索， 由于深度优先搜索，一直按照深度优先下去，故最坏情况为n*m， 而广度优先搜索，的...
计算机算法设计与分析第四章思维导图及知识点总结
XWBDurant的博客
11-24 1687
贪心算法的概念 贪心算法（又称贪婪算法）是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解。
啊哈算法—解救小哈（广度优先搜索）
m0_63852285的博客
04-26 344
解救小哈 小哈在一个（m * n)大小的迷宫（0 ⇐ m, n ⇐ 50）里迷路了。在迷宫中，每个单元格要么是空地，要么是障碍物。现在要找到从起点到小哈位置的最短步数。 思路： 使用队列储存扩展，扩展时每发现一个点就将这个点储存到队列中。当一个点扩展完毕，将其出队。 源码： #include<stdio.h> struct queue { int x; int y; int s; }; int main() { struct queue que[2500]; int t
啊哈算法系列-2023-10-11.pdf
10-11
啊哈算法系列-2023-10-11
啊哈算法-思维导图图片
02-17
算法思维导图
啊哈算法哈磊第四节再解炸弹人BFS算法(java)
最新发布
06-08
本资源深入解析了《啊哈算法》一书中的经典案例——第四节“再解炸弹人问题”，通过Java语言实现了BFS（广度优先搜索）算法的详细过程。本资源不仅涵盖了理论基础，详细阐述了BFS算法原理及其在解决“炸弹人”游戏...
啊哈，算法，部分程序.zip_啊哈 算法_啊哈算法
09-23
啊哈算法的程序，可以下载看看，主要是算法的程序
算法导论第四章答案
12-21
算法导论第四章答案算法导论第四章答案算法导论第四章答案算法导论第四章答案
算法2-啊哈算法！
qq_38446366的博客
04-25 3783
队列/栈/链表 队列 问题：小哈是小哼的新同桌，小哼向小哈询问 QQ 号，小哈给了小哼一串加密过的数字,同时小哈也告诉了小哼解密规则。规则是这样的:首先将第 1 个数删除,紧接着将第 2 个数放到这串数的末尾,再将第 3 个数删除并将第 4 个数放到这串数的末尾,再将第 5 个数删除…直到剩下最后一个数,将最后一个数也删除。按照刚才删除的顺序,把这些删除的数连在一起就是小哈的 QQ 啦。小哈给小哼...
【啊哈！算法】之图的广度优先搜索
『程序员·小李』的博客
07-17 503
我们仍然是从1到5，现在找到经过节点数最少的一条路线。其实把节点间的距离看做1的话，就是距离最短。 我们使用广度优先的思路解决： 首先，1号节点入队，找到与1号节点一步直达的节点，2号,3号 2号3号入队，1号出队， 找到2号节点一步直达的节点，1号,3号,4号，由于1号，3号都遍历过，只需要将4号入队。 2号出队， 找到3号节点一步直达的节点,1号,2号,4号,...
啊哈算法——万能的搜索——解救小哈DFS
_caorui_blog
07-30 1492
迷宫由n行m列的单元格组成（n和m都小于50），每个单元格要么是空地，要么是障碍物。你的任务是帮助小哼找到一条从迷宫的起点通往小哈所在位置的最短路径。 （障碍物不能走，且不可走到迷宫外） /*啊哈算法：解救小哈*/ #include &lt;stdio.h&gt; int n,m,p,q,min=99999999;//把min设置成很大的数 int a[51][51],book[51][5...
简单易懂数据结构和算法--《啊哈！算法》--图的遍历（广度优先搜索）
m0_46202433的博客
05-05 200
导叙：根据啊哈磊老师的《啊哈！算法》整理的学习笔记，如有侵权，联系删除 图书链接：https://pan.baidu.com/s/18qNteKTnKJJpdo7Dks50FA 提取码：ym1t 关注微信公众“伊斯电子编程”获取更多资源**** ...
《啊哈算法》第四章 万能的搜索之着色法
XQF
04-27 642
参考：《啊哈算法》 背景：宝岛探险。
《啊哈！算法》之图的遍历——深度广度优先算法
weixin_42512939的博客
08-20 1083
《啊哈！算法》之图的遍历——深度广度优先算法 什么是图 深度优先遍历 广度优先遍历 什么是图 简单地说，图就是由一些小圆点（称为顶点）和连接这些小圆点的直线（称为边）组成的 这些箭头代表着只能单向访问，比如只能A→B，不能B→A，为有向图，反之为无向图 数字代表着访问顺序 了解了什么是图过后那么我们怎么用程序把图表示出来 最常用的方法是用一个二维数组e...
《啊哈！算法》学习心得
博采众长，自成一派；
09-27 2910
文章目录内容概述第一章 一大波数正在靠近——排序第二章 栈、队列、链表第三章 枚举！很暴力第四章 万能的搜索第五章 图的遍历第六章 最短路径Floyd-Warshall算法Dijkstra算法Bellman Ford算法第七章 神奇的树第八章 更精彩的算法图的最小生成树图的割点图的割边二分图的最大匹配 一本通俗易懂、生动形象的算法书~作为算法入门指南是最合适不过的了 内容概述 书中涉及到的数据...
啊哈算法_全排列
diaobin0154的博客
07-29 183
//小哈面前有三个箱子，手上有1,2,3三张牌，规定能放小牌就放小牌，小哈放完最后一个箱子后，最后在箱子的牌能有几种排列? #include <iostream> #include <cstdio> using namespace std; int a[10],book[10],n; void dfs(int step) //step表示站在第几个盒子...
迷宫最短路径问题解析
热门推荐
a1259109679的专栏
08-29 1万+
有一个二维数组，0表示路，-1表示墙，求其中任意两点的最短路径。 我们先看，怎么求一条路径：求两点路径是一个数据结构上的典型的迷宫问题，很多数据结构的书上都有介绍，解决办法如下： 从一点开始出发，向四个方向查找，每走一步，把走过的点的值+1(即本节点值+1)，防止重复行走，并把走过的点压入堆栈(表示路径)，如果遇到墙、或者已走过的点则不能前进，如果前方已经无路可走，则返回，路径退栈，这

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值