多个出口的迷宫，求最短路径

最新推荐文章于 2018-08-14 20:09:01 发布
最新推荐文章于 2018-08-14 20:09:01 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： 数据结构 C语言 C++ 数据结构 linux笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jsbgo201506010102/article/details/80629312
版权 
//stack.h
#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include <stddef.h>

typedef struct point
{
    int row;
    int col;
}point;

#define SEQ_STACK_SIZE 100

typedef struct SeqStack
{
    point date[SEQ_STACK_SIZE];
    size_t size;
}SeqStack;

void SeqStackInit(SeqStack* stack);

void SeqStackDestory(SeqStack* stack);

void SeqStackPush(SeqStack* stack, point value);

void SeqStackPop(SeqStack* stack);

int SeqStackTop(SeqStack* stack, point* value);

void StackPrintf(SeqStack* stack);

int SeqStackSize(SeqStack* stack);

void SeqStackRplace(SeqStack* from, SeqStack* to);
//stack.c
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include"stack.h"

///////////////////////////////////
//        栈的初始化             //
///////////////////////////////////
void SeqStackInit(SeqStack* stack)
{
    if (stack == NULL)
    {
        return;
    }
    stack->size = 0;
}

///////////////////////////////////
//        栈的销毁               //
///////////////////////////////////
void SeqStackDestory(SeqStack* stack)
{
    if (stack == NULL)
    {
        return;
    }
    stack->size = 0;
}

///////////////////////////////////
//           压栈                //
///////////////////////////////////
void SeqStackPush(SeqStack* stack, point value)
{
    if (stack == NULL)
    {
        return;
    }
    if (stack->size > SEQ_STACK_SIZE - 1)
    {
        return;
    }
    stack->date[stack->size++] = value;
}


///////////////////////////////////
//           出栈                //
///////////////////////////////////
void SeqStackPop(SeqStack* stack)
{
    if (stack == NULL)
    {
        return;
    }
    if (stack->size == 0)
    {
        printf("栈为空\n");
        return;
    }
    stack->size = stack->size - 1;
}

///////////////////////////////////
//           取栈顶元素         //
///////////////////////////////////
int SeqStackTop(SeqStack* stack, point* value)
{
    if (stack == NULL)
    {
        return 0;
    }
    if (stack->size == 0)
    {
        printf("栈为空\n");
        return 0;
    }
    *value = stack->date[stack->size - 1];
    return 1;
}

///////////////////////////////////
//          栈的长度             //
///////////////////////////////////
int SeqStackSize(SeqStack* stack)
{
    if (stack == NULL)
    {
        return -1;
    }
    return stack->size;
}

///////////////////////////////////
//          替换栈               //
///////////////////////////////////
void SeqStackRplace(SeqStack* from, SeqStack* to)
{
    if (from == NULL || to == NULL)
    {
        return;
    }
    SeqStackDestory(to);
    size_t i = 0;
    for (i = 0; i < from->size; ++i)
    {
        to->date[to->size++] = from->date[i];
    }
}

///////////////////////////////////
//           打印栈              //
///////////////////////////////////
void StackPrintf(SeqStack* stack)
{
    printf("[栈底]");
    printf("\n");
    size_t i = 0;
    for (i = 0; i < (stack->size); ++i)
    {
        printf(" (%d, %d) ", stack->date[i].row,stack->date[i].col);
        printf("\n");
    }
    printf("[栈顶]\n");
}
//递归的方法求最短路径
#include<stdio.h>
#include<stdlib.h>
#include"stack.h"

#define MAZE_ROW 6
#define MAZE_COL 6

typedef struct Maze
{
    int map[MAZE_ROW][MAZE_COL];
}Maze;

void MazeInit(Maze* maze)
{
    int map[MAZE_ROW][MAZE_COL] =
    {
        { 0,1,0,0,0,0 },
        { 0,1,1,1,0,0 },
        { 0,1,0,1,1,1 },
        { 0,1,1,1,0,0 },
        { 0,1,0,1,1,0 },
        { 0,1,0,0,1,0 }
    };
    int i = 0;
    int j = 0;
    for (i = 0; i<MAZE_ROW; ++i)
        for (j = 0; j<MAZE_COL; ++j)
        {
            maze->map[i][j] = map[i][j];
        }
}

void MazePrint(Maze *maze)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < MAZE_ROW; ++i)
    {
        for (j = 0; j < MAZE_COL; ++j)

        {
            printf("%2d ", maze->map[i][j]);
        }
        printf("\n");
    }
}

//判断是不是落脚点
int Is_Stay(Maze *maze, point pos)
{
    if (pos.row < 0 || pos.row > MAZE_ROW - 1
        || pos.col < 0 || pos.col > MAZE_COL - 1
        || maze->map[pos.row][pos.col] != 1)
        return 0;
    else
        return 1;
}



int Is_Chukou(point pos, point entry)
{
    if ((pos.row == 0) || (pos.row == MAZE_ROW - 1)
        || (pos.col == 0) || (pos.col == MAZE_COL - 1))
    {
        if (pos.row == entry.row  && pos.col == entry.col)
            return 0;
        else
            return 1;
    }
    return 0;

}

int Is_Stay_Wirh_Cirl(Maze* maze, point cur, point pre)
{
    if (pre.row < 0 || pre.col < 0)
    {
        //如果之前的点非法，也就是当前点是第一个点，那我们直接判断cur是否能落脚
        if (cur.row < 0 || cur.row > MAZE_ROW - 1
            || cur.col < 0 || cur.col > MAZE_COL - 1 && maze->map[cur.row][cur.col] == 0)
            return 0;
        else
            return 1;
    }
    else
    {
        //1.判断当前点是否在地图上
        if (cur.row < 0 || cur.row > MAZE_ROW - 1
            || cur.col < 0 || cur.col > MAZE_COL - 1)
            return 0;
        //2.判断当前点的值是否为1，如果是1，一定能落脚
        if(maze->map[cur.row][cur.col] == 0)
            return 0;
        if (maze->map[cur.row][cur.col] == 1)
            return 1;
        //判断当前点的值和前一个点值的大小   当前点的值 - 1  <   之前的值，就可以落脚
        if (maze->map[cur.row][cur.col] > maze->map[pre.row][pre.col] + 1)
        {
            return 1;
        }
    }
    return 0;
}

void Mark_With_Cirl(Maze* maze, point cur,point pre)
{

    if (pre.row < 0 || pre.col < 0)
    {
        maze->map[cur.row][cur.col] ++;
    }
    else

    maze->map[cur.row][cur.col] = maze->map[pre.row][pre.col] + 1;
}

void _GetShort_pathWith_Cirl(Maze* maze, point cur, point pre, point entry, SeqStack* cur_path, SeqStack* short_path)
{
    if (cur_path == NULL || short_path == NULL)
    {
        return;
    }
    //1.判断当前点是否能落脚
    if (!(Is_Stay_Wirh_Cirl(maze, cur, pre)))
    {
        return;
    }
    //2.标记当前点，并push到cur_path,

    Mark_With_Cirl(maze, cur,pre);
    SeqStackPush(cur_path, cur);
    //3.判断当前点是不是出口，如果是出口，比较cur_push和short_path的长度
    //a. 如果cur_push比short_path短，或者short_path为空，用cur_path替换short_path
    if (Is_Chukou(cur, entry))
    {
        //a)比较当前的cur_path和short_path的长短
        //b)如果cur_path比short_path小  或者   short_path为空
        if (SeqStackSize(cur_path) < SeqStackSize(short_path) || SeqStackSize(short_path) == 0)
        {
            //用cur_path替换short_path
            SeqStackRplace(cur_path, short_path);
        }

        printf("找到一条路径：\n");
        StackPrintf(cur_path);
        printf("当前最短路径为：\n");
        StackPrintf(short_path);
        //c)让cur_path出栈，返回到上一层栈帧
        SeqStackPop(cur_path);
        return;
    }
    //4.按照一定的顺序，递归的调用该函数，完成领节点的判断
    point up = cur;
    up.row -= 1;
    _GetShort_pathWith_Cirl(maze,  up, cur, entry, cur_path, short_path);

    point right = cur;
    right.col += 1;
    _GetShort_pathWith_Cirl(maze,  right, cur ,entry, cur_path, short_path);

    point down = cur;
    down.row += 1;
    _GetShort_pathWith_Cirl(maze,  down, cur, entry, cur_path, short_path);

    point left = cur;
    left.col -= 1;
    _GetShort_pathWith_Cirl(maze,   left, cur, entry, cur_path, short_path);

    //5.cur_path出栈，回溯到上一个位置 
    SeqStackPop(cur_path);
    return;


}

void GetShort_pashWith_Cirl(Maze *maze, point entry)
{
    if (maze == NULL)
    {
        return;
    }
    if (!Is_Stay(maze, entry))
    {
        return;
    }
    SeqStack short_path;
    SeqStackInit(&short_path);
    SeqStack cur_path;
    SeqStackInit(&cur_path);
    point cur = entry;
    point pre = { -1,-1 };
    _GetShort_pathWith_Cirl(maze, cur, pre, entry, &cur_path, &short_path);
    printf("最终的最短路径为：\n");
    StackPrintf(&short_path);

}

void TestInit()
{
    Maze maze;
    MazeInit(&maze);
    MazePrint(&maze);
}
void Test()
{
    Maze maze;
    MazeInit(&maze);
    MazePrint(&maze);
    point pos = { 0,1 };
    //GetShort_pash(&maze, pos);
    GetShort_pashWith_Cirl(&maze, pos);
    MazePrint(&maze);
}

int main()
{
    //TestInit();
    Test();
    system("pause");
    return 0;
}




//循环的方法求最短路径
#include<stdio.h>
#include<stdlib.h>
#include"stack.h"

#define MAZE_ROW 6
#define MAZE_COL 6

typedef struct Maze
{
    int map[MAZE_ROW][MAZE_COL];
}Maze;

void MazeInit(Maze* maze)
{
    int map[MAZE_ROW][MAZE_COL] =
    {
        { 0,1,0,0,0,0 },
        { 0,1,1,1,0,0 },
        { 0,1,0,1,1,1 },
        { 0,1,1,1,0,0 },
        { 0,1,0,1,1,0 },
        { 0,1,0,0,1,0 }
    };
    int i = 0;
    int j = 0;
    for (i = 0; i<MAZE_ROW; ++i)
        for (j = 0; j<MAZE_COL; ++j)
        {
            maze->map[i][j] = map[i][j];
        }
}

void MazePrint(Maze *maze)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < MAZE_ROW; ++i)
    {
        for (j = 0; j < MAZE_COL; ++j)

        {
            printf("%2d ", maze->map[i][j]);
        }
        printf("\n");
    }
}

//判断是不是落脚点
int Is_Stay(Maze *maze, point pos)
{
    if (pos.row < 0 || pos.row > MAZE_ROW - 1
        || pos.col < 0 || pos.col > MAZE_COL - 1
        || maze->map[pos.row][pos.col] != 1)
        return 0;
    else
        return 1;
}



int Is_Chukou(point pos, point entry)
{
    if ((pos.row == 0) || (pos.row == MAZE_ROW - 1)
        || (pos.col == 0) || (pos.col == MAZE_COL - 1))
    {
        if (pos.row == entry.row  && pos.col == entry.col)
            return 0;
        else
            return 1;
    }
    return 0;

}

int Is_Stay_Wirh_Cirl(Maze* maze, point cur, point pre)
{
    if (pre.row < 0 || pre.col < 0)
    {
        //如果之前的点非法，也就是当前点是第一个点，那我们直接判断cur是否能落脚
        if (cur.row < 0 || cur.row > MAZE_ROW - 1
            || cur.col < 0 || cur.col > MAZE_COL - 1 && maze->map[cur.row][cur.col] == 0)
            return 0;
        else
            return 1;
    }
    else
    {
        //1.判断当前点是否在地图上
        if (cur.row < 0 || cur.row > MAZE_ROW - 1
            || cur.col < 0 || cur.col > MAZE_COL - 1)
            return 0;
        //2.判断当前点的值是否为1，如果是1，一定能落脚
        if (maze->map[cur.row][cur.col] == 0)
            return 0;
        if (maze->map[cur.row][cur.col] == 1)
            return 1;
        //判断当前点的值和前一个点值的大小   当前点的值 - 1  <   之前的值，就可以落脚
        if (maze->map[cur.row][cur.col] > maze->map[pre.row][pre.col] + 1)
        {
            return 1;
        }
    }
    return 0;
}

void Mark_With_Cirl(Maze* maze, point cur, point pre)
{

    if (pre.row < 0 || pre.col < 0)
    {
        maze->map[cur.row][cur.col] ++;
    }
    else

        maze->map[cur.row][cur.col] = maze->map[pre.row][pre.col] + 1;
}

void _GetShort_pathWith_Cirl(Maze* maze, point cur, point pre, point entry, SeqStack* cur_path, SeqStack* short_path)
{
    if (cur_path == NULL || short_path == NULL)
    {
        return;
    }
    //1.入口是否能落脚
    if (!(Is_Stay_Wirh_Cirl(maze, cur, pre)))
    {
        return;
    }
    SeqStack stack;
    SeqStackInit(&stack);
    //2.标记入口点，入口点入栈 ,还要入cur_path
    Mark_With_Cirl(maze, cur, pre);
    SeqStackPush(&stack, cur);
    SeqStackPush(cur_path, cur);
    //3.进入循环，取栈顶为当前点
    while (SeqStackTop(&stack , &cur))
    {
        //4.判断当前点是不是出口，若是出口
        if ((Is_Chukou(cur, entry)))
        {
            // a)比较cur_path的长度，如果比short_path短，或者short_path为空
            //用cur_path替换short_path

            if (SeqStackSize(cur_path) < SeqStackSize(short_path) || SeqStackSize(short_path) == 0)
            {
                //用cur_path替换short_path
                SeqStackRplace(cur_path, short_path);
            }

            printf("找到一条路径：\n");
            StackPrintf(cur_path);
            printf("当前最短路径为：\n");
            StackPrintf(short_path);
            //  b)栈出栈，cur_path出栈，进行下一次循环
            SeqStackPop(&stack);
            SeqStackPop(cur_path);
            continue;
        }

        //5.按照一定的顺序判断邻节点，若邻接点能够落脚，入栈，也入cur_path,进入下一次循环
        point up = cur;
        up.row -= 1;
        if (Is_Stay_Wirh_Cirl(maze, up, cur))
        {
            Mark_With_Cirl(maze,up, cur);
            SeqStackPush(&stack, up);
            SeqStackPush(cur_path, up);
            continue;
        }

        point right = cur;
        right.col += 1;
        if (Is_Stay_Wirh_Cirl(maze, right, cur))
        {
            Mark_With_Cirl(maze, right, cur);
            SeqStackPush(&stack, right);
            SeqStackPush(cur_path, right);
            continue;
        }

        point down = cur;
        down.row += 1;
        if (Is_Stay_Wirh_Cirl(maze, down, cur))
        {
            Mark_With_Cirl(maze, down, cur);
            SeqStackPush(&stack, down);
            SeqStackPush(cur_path, down);
            continue;
        }

        point left = cur;
        left.row -= 1;
        if (Is_Stay_Wirh_Cirl(maze, left, cur))
        {
            Mark_With_Cirl(maze, left , cur);
            SeqStackPush(&stack, left);
            SeqStackPush(cur_path, left);
            continue;
        }

        //6.四周都判断完后，回溯到下一个位置，栈出栈，
        SeqStackPop(&stack);
        SeqStackPop(cur_path);
    }



}

void GetShort_pashWith_Cirl(Maze *maze, point entry)
{
    if (maze == NULL)
    {
        return;
    }
    if (!Is_Stay(maze, entry))
    {
        return;
    }
    SeqStack short_path;
    SeqStackInit(&short_path);
    SeqStack cur_path;
    SeqStackInit(&cur_path);
    point cur = entry;
    point pre = { -1,-1 };
    _GetShort_pathWith_Cirl(maze, cur, pre, entry, &cur_path, &short_path);
    printf("最终的最短路径为：\n");
    StackPrintf(&short_path);

}

void TestInit()
{
    Maze maze;
    MazeInit(&maze);
    MazePrint(&maze);
}
void Test()
{
    Maze maze;
    MazeInit(&maze);
    MazePrint(&maze);
    point pos = { 0,1 };
    //GetShort_pash(&maze, pos);
    GetShort_pashWith_Cirl(&maze, pos);
    MazePrint(&maze);
}

int main()
{
    //TestInit();
    Test();
    system("pause");
    return 0;
}
csdn_JSB
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
求迷宫的最短路径：现要求设计一个算法找一条从迷宫入口到出口的最短路径。
11-25
本算法要求找一条迷宫的最短路径，算法的基本思想为：从迷宫入口点（1,1）出发，向四周搜索，记下所有一步能到达的坐标点；然后依次再从这些点出发，再记下所有一步能到达的坐标点，…，依此类推，直到到达迷宫的出口点(m,n)为止，然后从出口点沿搜索路径回溯直至入口。这样就找到了一条迷宫的最短路径，否则迷宫无路径。
求迷宫最短通道
长夜漫漫，无心睡眠
10-23 2600
题目： 递归求解迷宫最短通道的总步长。输入一个迷宫，求从入口通向出口的可行路径中最短的路径长度。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze...
【数据结构】求多出口迷宫的最短路径（递归版本）
Qregi的博客
02-03 1582
Maze.h #pragma once #include typedef struct Pos{ int _Row; int _COL; }Pos; typedef struct Maze{ struct Pos pos; }Maze; Maze.c #define _CRT_SECURE_NO_WARNINGS 1 #include #include"Maze.
迷宫---多出口迷宫的最短路径
Nessie_zhao的博客
05-05 4024
如图是一个有三个出口的迷宫，现在来求它的最短路径（不带环） 思想：定义两个栈，一个栈存放当前路径。一个栈存最短路径，每次都将当前路径和最短路径比较如果当前路径小于最短路径，那就交换两个栈中的元素 代码实现：void MazeInit2(Maze* maze) { if(maze == NULL) { return; } int map[MAX_R
多出口迷宫最短路径求解
Xucc_x的博客
04-23 2666
问题引出 有的时候，除了只有一条出口的迷宫外，我们还会遇到多出口迷宫求解问题，即 有多条出口的迷宫，迷宫内部各路径不交叉，不成环，求其中最短的一条路径 例如： 关于单出口的简单迷宫求解，大家可以参考 简单迷宫求解 解题思路 因为迷宫中存在多条路径，所以这次我们采用自己构造栈的方式进行求解 构建两个栈，一个栈为 cur_path，保存当前走过的路径，另一个栈为 ...
C语言支持自己创建迷宫，并求解最短路径.zip
最新发布
08-31
它可以在多个操作系统上运行，包括Windows、Linux和Mac OS等。这使得开发人员可以在不同的环境中使用同一套工具和库，从而提高了开发的灵活性和效率。 该项目还具有高度可定制性。开发人员可以根据自己的需求和偏好...
matlab-迷宫路径
03-30
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。 输入两个整数，分别表示二位数组的行数...
迷宫问题 代码及详解
12-05
创建一个迷宫, 一个迷宫由多个房间（Room）组成，一个房间知道它的邻居；可能的邻居要么是一个房间（Room）、一堵墙（Wall）或通往另一个房间的一扇门（Door）。。。
A*算法求解迷宫寻路问题实验
12-16
1.画出用A”算法求解迷宫最短路径的流程图。 2.设置不同的地图,以及不同的初始状态和目标状态,记录A`算法的求解结果,包括最短路径、扩展节点数、生成节点数和算法运行时间。 3.对于相同的初始状态和目标状态,设计...
maze:用强化学习解决迷宫
05-30
该项目将相同的强化学习 (RL) 概念应用于迷宫学习，因为求解器试图找到从迷宫左上角到右下角的最短路径。 虽然其他算法在解决静态迷宫时会快得多（例如，蛮力方法会更快），但这种解决算法以其如何存储其状态和...
迷宫的求解问题 多条路径
06-21
迷宫问题指/向第一个结点的栈顶指针 public: Stack(); //构造函数，置空栈 ~Stack(); //析构函数 void Push(T e); //把元素data压入栈中 T Pop(); //使栈顶元素出栈 T GetPop(); //取出栈顶元素 void Clear(); //把栈清空 bool empty(); //判断栈是否为空，如果为空则返回1，否则返回0 };
多个迷宫代码的C++实现
12-23
用C++代码实现了几种迷宫，包括路径的搜索算法，希望对各位有帮助
一个求迷宫入口到出口最近距离的程序
liangbch的专栏
05-23 6174
本文给出一个c/c++语言版的求迷宫入口到出口的最短路径的程序。程序的大部分使用标准c语言编写，包括 输入和输出。唯一用到C++库的地方是使用STL了中的deque。迷宫的宽和高，迷宫矩阵，迷宫的入口和出口 等数据从文件读入。程序首先读入迷宫数据，然后更新迷宫矩阵，并求出迷宫入口和出口之间的最短路径， 并输出最短路径长度。 1. 迷宫的表示。 迷宫用结构体MATRIX来表示 包括迷
【数据结构】简单迷宫：假设只有一个出口
如风逝去
11-20 620
#define _CRT_SECURE_NO_WARNINGS //这里的迷宫用二位数组表示，1表示能走通其他表示不能走通 #include #include using namespace std; struct Seat//储存坐标 { Seat(int x, int y) : _x(x), _y(y) {} int _x; int _y; }; #define ROW 10 #
迷宫（多出口）
VergiL Wang的专栏
12-10 3136
/*  * =====================================================================================  *  *       Filename:  maze.c  *  *    Description:    *  *        Version:  1.0  *        Created:
无法打开内核设备“\\.\Global\vmx86”: 系统找不到指定的文件。是否在安装 VMwar
JSB的博客
06-21 4763
点击“开始→运行”，在运行框中输入 cmd 回车打开命令提示符，然后依次执行以下命令 输入以下的命令并回车 net start vmci net start vmx86 net start VMnetuserif 改变vmware几种服务的启动方式为： sc config vmci start= auto sc config vmx86 start= auto sc config...
C/C++内存管理方式
JSB的博客
08-14 2534
1.栈又叫堆栈，非静态局部变量/函数参数/返回值等，栈是向下增长的。 2.内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。 3.堆用于程序运行时动态内存分配，堆是向上增长的 4.数据段———存储全局数据和静态数据 5.代码段———可执行的代码/只读常量 malloc / calloc /reallo...
浅谈mian函数的参数解析
JSB的博客
04-24 2114
我们从一开始接触C语言就在使用mian函数，但你们有没有发main函数其实也是被调用的，而且main函数还是有参数的。 main函数在_tmainCRTStartup函数中调用的，而_tmainCRTStartup函数是被mianCRTStartup调用的。这里我们主要讲main函数的参数，那我们先看看main函数的原型： int main(int argc,char *argv[],...
迷宫问题中怎么求最短路径
05-04
求解迷宫问题的最短路径可以使用广度优先搜索（BFS）算法。 BFS算法是从起点开始，将其周围的节点加入队列中，然后依次访问队列中的节点，将其周围的节点加入队列中，直到找到终点或者搜索完所有可达节点为止。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值