三子棋＜不是笨比电脑＞

已于 2022-11-11 22:12:15 修改
阅读量142 收藏
点赞数
文章标签： c语言 c++ 游戏
于 2022-11-10 23:58:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64220349/article/details/127794070
版权

目录

一、流程图

 二、实现思路

三、函数实现

1、菜单

2、初始化

3. 打印棋盘

4、玩家下棋

5、电脑下棋

6、胜负判断

四、全部代码

一、流程图

 二、实现思路

程序主要分为：菜单，棋盘初始化，打印棋盘，玩家下棋，电脑下棋，胜负判断，几个模块。

那么我们先声明好函数。（棋盘使用3行3列的二维char数组来表示，如果使用全局变量的话可以不用传参，憋别问我为什么传）

#define ROW 3
#define COL 3
int menu();                                         //菜单
void init(char che[ROW][COL]);                      //初始化棋盘
void display(char che[ROW][COL], int row, int col); //打印棋盘
void player(char che[ROW][COL]);                    // 玩家回合
void computer(char che[ROW][COL]);                  //电脑回合
int detect(char che[ROW][COL]);                     //输赢检测

三、函数实现

1、菜单

一个好的菜单往往是一款......（省略1万字精髓），所以我相信，大家一定能轻松地完成一个精美的菜单，以下只是一个参考。

int menu(){
  puts("--------------------------");
	puts("   ***    三子棋    ***   ");
  puts("--------------------------");
	puts("--------1.开始游戏--------");
	puts("--------0.退出游戏--------");
	puts("--------------------------");
	int choice = 0;
	puts("请作出你的选择：");
	scanf("%d", &choice);
	return choice;
}

2、初始化

错误的初始化：char che[3][3]={' '};

数组初始化没写的地方默认为0，这也是为什么int arr[5]={0};数组就全为零的原因，所以要用for循环来一一赋值。

void init(char che[ROW][COL])
{
    int i, j;
    for (j = 0; j < ROW; j++)
        for (i = 0; i < COL; i++)
            che[j][i] = ' ';

}

3. 打印棋盘

需要注意的地方只有，换行，printf()不会自己加换行，puts()会，大多数时候我单独加换行时用的是puts("");而不是printf("\n");

void display(char che[ROW][COL], int row, int col)
{
    int i, j;
    for (j = 0; j < row; j++)
    {
        for (i = 0; i < col; i++)
        {
            printf("%c ", che[j][i]);
            if (i != col - 1)
                printf("|");
        }
        puts("");
        if (j != row - 1)
            for (i = 0; i < col; i++)
            {
                printf("--");
                if (i != col - 1)
                    printf("|");
            }
        puts("");
    }

    return;
}

4、玩家下棋

除了下的位置不能超出棋盘，记得别让玩家下在已经下过的位置了，不然三步秒刷电脑就没意思了。（*号是玩家下的，#号是电脑下的）


void player(char che[ROW][COL])
{
    int i, j;
    printf("请输入你要走的位置（例：1,3）\n");
    scanf("%d,%d", &i, &j);

    while (1)
    {
        if (i > 0 && i <= ROW && j > 0 && j <= COL && che[i - 1][j - 1] != '#' && che[i - 1][j - 1] != '*')
        {
            
                che[i - 1][j - 1] = '*';
            break;
        }
        printf("棋盘上没有此位置，或此位置已被占用，请重新输入（例：1,3）\n");
        scanf("%d,%d", &i, &j);
    }
}

5、电脑下棋

相信不少人是为了这里来看的，我就不废话了，我的思路是给电脑制定一个底层逻辑，第一步统计一行一列一个对角线的玩家棋子和电脑棋子的个数，然后先判断是否有电脑将赢的情况（三个只差一个了），再判断是否有玩家将赢的情况，再去防守。（毕竟，我能推你家水晶还要高地干嘛）。

相信大家也看出来了，这个逻辑只能能处理两种情况，那么第三种没有‘成双’的情况（比如说电脑的第一步），我考虑了两种方式来解决：

（1）、随机放<doge>哎呀，别走呀！我不会搞出这种第二步乱走的笨比的。

直接讲方法二吧，我已经提前把第一步的最优解求出来了，走了第一步，如果玩家想赢走出来的结果就大概率会出现前面的逻辑能处理的问题。

那么如果1进入特殊最后几步（没有成双，但只有一个棋子位），2或者玩家故意放海了捏？

放心，

第一个问题解决方案，因为在我写的逻辑里，判断成双之后是否能下的原理是，遇到空格就记录并标记这行，空格的位置存下，到了下一行只是把flag变0，空格位置不删。

 所以只要在最后逻辑判断不成立之后直接用m，n里的不知道从哪一行拐过来的空位就行了。

（棋子满了是检测函数该干的是，管我什么事）

第二个问题解决方案（提前考虑）

玩家放水太多，那我直接在上一个解决方案随机空位放置之前试一试能不能下中间，能下中间就放了，这样成双的概率特别大，如果不能，那就不叫放海了！

函数代码

void computer(char che[ROW][COL])
{
    int i, j;
    if (round == 0) //第一步得帮电脑走
    {
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COL; j++)
                if (che[i][j] == '*') //找到玩家的第一步
                    break;
            if (j < COL) //二层跳出
                break;
        }
        if (i == j)
            che[0][2] = '#'; 
        else if (i == 0 && j == 2)
            che[1][1] = '#';
        else if (i == 2 && j == 0)
            che[1][1] = '#';
        else if (i - j == 1 || j - i == 1)
            che[1][1] = '#';

        round++; //第一步结束
        return;
    }
    else
    {

        int m, n, flag = 0; //m,n存储空位,flag判断空位是否位于这一回2
        int p = 0, c = 0;   //电脑和玩家的棋子数
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COL; j++)
            {
                if (che[i][j] == '*')
                    p++;
                if (che[i][j] == '#')
                    c++;
                if (che[i][j] == ' ')
                    m = i, n = j, flag = 1;//此时标记这个空位是这一行的,每过一行flag变0，m,n不丢
            }

            if (c == 2 && flag) //优先选择胜出路线
            {
                che[m][n] = '#';
                return;
            }
            if (p == 2 && flag) //第二优先防御路线
            {
                che[m][n] = '#';
                return;
            }
            p = 0, c = 0, flag = 0;
        }
        p = 0, c = 0, flag = 0;
        for (i = 0; i < COL; i++) //竖直
        {
            for (j = 0; j < ROW; j++)
            {
                if (che[j][i] == '*')
                    p++;
                if (che[j][i] == '#')
                    c++;
                if (che[j][i] == ' ')
                    m = j, n = i, flag = 1;
            }
            if (c == 2 && flag) //优先选择胜出路线
            {
                che[m][n] = '#';
                return;
            }
            if (p == 2 && flag) //第二优先防御路线
            {
                che[m][n] = '#';
                return;
            }
            p = 0, c = 0, flag = 0;
        }
        p = 0, c = 0;
        for (i = 0, j = 0; i < 3; i++, j++)
        {
            if (che[i][j] == '*')
                p++;
            if (che[i][j] == '#')
                c++;
            if (che[i][j] == ' ')
                m = i, n = j;
        }
        if (c == 2) //优先选择胜出路线
        {
            che[m][n] = '#';
            return;
        }
        if (p == 2) //第二优先防御路线
        {
            che[m][n] = '#';
            return;
        }
        p = 0, c = 0;
        for (i = 0, j = 2; i < 3; i++, j--)
        {
            if (che[i][j] == '*')
                p++;
            if (che[i][j] == '#')
                c++;
            if (che[i][j] == ' ')
                m = i, n = j;
        }
        if (c == 2) //优先选择胜出路线
        {
            che[m][n] = '#';
            return;
        }
        if (che[1][1] == ' ') //判断到到这里说明多半是平局或者是玩家的迷惑操作，如果是玩家想让电脑赢那么走中就可以抓住机会
            che[1][1] = '#';
        else
            che[m][n] = '#'; //最后m，n里一定储存了一个空位
        return;
    }
}

但聪明的的你一定看出来了，这样逻辑上还是有一些漏洞吧，但经过我的测试，这样电脑已经不能算是笨比了，它已经成功的进化成了二比，大多数该抓的机会已经会抓住了。

本人能力有限，只能做到这个地步了（其实我还有一个大胆的想法，穷举，但我觉得这样写就没有思考意义了）

6、胜负判断

不多说，不难（对角线我直接判断的）返回值决定胜负

int detect(char che[ROW][COL])
{
    int p = 0, c = 0, count = 0;

    int i, j;
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            if (che[i][j] == '*')
                p++, count++; //这里统计了所有棋子数
            if (che[i][j] == '#')
                c++, count++;
        }
        if (p == 3)
            return 1; //玩家胜
        if (c == 3)
            return -1;//电脑胜
        p = 0, c = 0;
    }
    p = 0, c = 0;
    for (i = 0; i < COL; i++)
    {
        for (j = 0; j < ROW; j++)
        {
            if (che[j][i] == '*')
                p++;
            if (che[j][i] == '#')
                c++;
        }
        if (p == 3)
            return 1;//玩家胜
        if (c == 3)
            return -1;//电脑胜
        p = 0, c = 0;
    }

    if (che[0][0] == '*' && che[1][1] == '*' && che[2][2] == '*')
        return 1;
    if (che[0][2] == '*' && che[1][1] == '*' && che[2][0] == '*')
        return 1;
    if (che[0][0] == '#' && che[1][1] == '#' && che[2][2] == '#')
        return -1;
    if (che[0][2] == '#' && che[1][1] == '#' && che[2][0] == '#')
        return -1;

    if (count == 9)
        return 55;//平局
    else
        return 0; 
}

四、全部代码

#include <stdio.h>
#include <windows.h>
#define ROW 3
#define COL 3
int round; //回合数，用于电脑出招判断

int menu();                                         //菜单
void init(char che[ROW][COL]);                      //初始化棋盘，回合数。。
void display(char che[ROW][COL], int row, int col); //打印棋盘
void player(char che[ROW][COL]);                    // 玩家回合
void computer(char che[ROW][COL]);                  //电脑回合(仅适用于三子棋)
int detect(char che[ROW][COL]);                     //输赢检测(仅用于三子棋)

int main()
{
    char che[ROW][COL];
    char i; //游戏是否继续的判断
    while (menu())
    {
        system("cls");//清屏更舒适
        init(che);
        display(che, ROW, COL);

        while (1)
        {

            player(che);
            puts("玩家下");            
            display(che, ROW, COL);
            Sleep(1000);

            puts("电脑下");
            computer(che);
            display(che, ROW, COL);
            Sleep(1000);

            if (detect(che))
                break;
        }

        if (detect(che) == 1)
        {
            system("cls");
            puts("恭喜你，获胜了！");
        }

        else if (detect(che) == -1)
        {
            system("cls");
            puts("很遗憾，你输了。");
        }

        Sleep(1000);
        system("pause");
        system("cls");
        puts("是否继续游戏（y/n）");
        fflush(stdin);
        scanf("%c", &i);
        if (i == 'n')
            break;
    }
    return 0;
}
int menu(){
  puts("--------------------------");
	puts("   ***    三子棋    ***   ");
  puts("--------------------------");
	puts("--------1.开始游戏--------");
	puts("--------0.退出游戏--------");
	puts("--------------------------");
	int choice = 0;
	puts("请作出你的选择：");
	scanf("%d", &choice);
	return choice;
}
void display(char che[ROW][COL], int row, int col)
{
    int i, j;
    for (j = 0; j < row; j++)
    {
        for (i = 0; i < col; i++)
        {
            printf("%c ", che[j][i]);
            if (i != col - 1)
                printf("|");
        }
        puts("");
        if (j != row - 1)
            for (i = 0; i < col; i++)
            {
                printf("--");
                if (i != col - 1)
                    printf("|");
            }
        puts("");
    }

    return;
}
void init(char che[ROW][COL])
{
    int i, j;
    for (j = 0; j < ROW; j++)
        for (i = 0; i < COL; i++)
            che[j][i] = ' ';

    round = 0; //回合数归零
}

void player(char che[ROW][COL])
{
    int i, j;
    printf("请输入你要走的位置（例：1,3）\n");
    scanf("%d,%d", &i, &j);

    while (1)
    {
        if (i > 0 && i <= ROW && j > 0 && j <= COL && che[i - 1][j - 1] != '#' && che[i - 1][j - 1] != '*')
        {
            
                che[i - 1][j - 1] = '*';
            break;
        }
        printf("棋盘上没有此位置，或此位置已被占用，请重新输入（例：1,3）\n");
        scanf("%d,%d", &i, &j);
    }
}
void computer(char che[ROW][COL])
{
    int i, j;
    if (round == 0) //第一步得帮电脑走
    {
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COL; j++)
                if (che[i][j] == '*') //找到玩家的第一步
                    break;
            if (j < COL) //二层跳出
                break;
        }
        if (i == j)
            che[0][2] = '#'; 
        else if (i == 0 && j == 2)
            che[1][1] = '#';
        else if (i == 2 && j == 0)
            che[1][1] = '#';
        else if (i - j == 1 || j - i == 1)
            che[1][1] = '#';

        round++; //第一步结束
        return;
    }
    else
    {

        int m, n, flag = 0; //m,n存储空位,flag判断空位是否位于这一回2
        int p = 0, c = 0;   //电脑和玩家的棋子数
        for (i = 0; i < ROW; i++)
        {
            for (j = 0; j < COL; j++)
            {
                if (che[i][j] == '*')
                    p++;
                if (che[i][j] == '#')
                    c++;
                if (che[i][j] == ' ')
                    m = i, n = j, flag = 1;//此时标记这个空位是这一行的,每过一行flag变0，m,n不丢
            }

            if (c == 2 && flag) //优先选择胜出路线
            {
                che[m][n] = '#';
                return;
            }
            if (p == 2 && flag) //第二优先防御路线
            {
                che[m][n] = '#';
                return;
            }
            p = 0, c = 0, flag = 0;
        }
        p = 0, c = 0, flag = 0;
        for (i = 0; i < COL; i++) //竖直
        {
            for (j = 0; j < ROW; j++)
            {
                if (che[j][i] == '*')
                    p++;
                if (che[j][i] == '#')
                    c++;
                if (che[j][i] == ' ')
                    m = j, n = i, flag = 1;
            }
            if (c == 2 && flag) //优先选择胜出路线
            {
                che[m][n] = '#';
                return;
            }
            if (p == 2 && flag) //第二优先防御路线
            {
                che[m][n] = '#';
                return;
            }
            p = 0, c = 0, flag = 0;
        }
        p = 0, c = 0;
        for (i = 0, j = 0; i < 3; i++, j++)
        {
            if (che[i][j] == '*')
                p++;
            if (che[i][j] == '#')
                c++;
            if (che[i][j] == ' ')
                m = i, n = j;
        }
        if (c == 2) //优先选择胜出路线
        {
            che[m][n] = '#';
            return;
        }
        if (p == 2) //第二优先防御路线
        {
            che[m][n] = '#';
            return;
        }
        p = 0, c = 0;
        for (i = 0, j = 2; i < 3; i++, j--)
        {
            if (che[i][j] == '*')
                p++;
            if (che[i][j] == '#')
                c++;
            if (che[i][j] == ' ')
                m = i, n = j;
        }
        if (c == 2) //优先选择胜出路线
        {
            che[m][n] = '#';
            return;
        }
        if (che[1][1] == ' ') //判断到到这里说明多半是平局或者是玩家的迷惑操作，如果是玩家想让电脑赢那么走中就可以抓住机会
            che[1][1] = '#';
        else
            che[m][n] = '#'; //最后m，n里一定储存了一个空位
        return;
    }
}
int detect(char che[ROW][COL])
{
    int p = 0, c = 0, count = 0;

    int i, j;
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            if (che[i][j] == '*')
                p++, count++; //这里统计了所有棋子数
            if (che[i][j] == '#')
                c++, count++;
        }
        if (p == 3)
            return 1; //玩家胜
        if (c == 3)
            return -1;
        p = 0, c = 0;
    }
    p = 0, c = 0;
    for (i = 0; i < COL; i++)
    {
        for (j = 0; j < ROW; j++)
        {
            if (che[j][i] == '*')
                p++;
            if (che[j][i] == '#')
                c++;
        }
        if (p == 3)
            return 1;
        if (c == 3)
            return -1;
        p = 0, c = 0;
    }

    if (che[0][0] == '*' && che[1][1] == '*' && che[2][2] == '*')
        return 1;
    if (che[0][2] == '*' && che[1][1] == '*' && che[2][0] == '*')
        return 1;
    if (che[0][0] == '#' && che[1][1] == '#' && che[2][2] == '#')
        return -1;
    if (che[0][2] == '#' && che[1][1] == '#' && che[2][0] == '#')
        return -1;

    if (count == 9)
        return 55;
    else
        return 0; //平局
}

典128
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
五子棋简化版 -- 三子棋（C语言）
YeLing0119的博客
10-26 630
五子棋简化版 -- 三子棋         相信大家对五子棋很熟悉吧，但是我们如何用C语言来写一个五子棋游戏呢？这对于我们初学者来说可能有点困难，但是我们何尝不能先把问题简化一下呢？先易后难，循序渐进才是学习的王道。让我们一起来看一下简化后的三子棋规则是什么样子的。         三子棋规则：                 棋盘为3*3的棋盘，玩家先手，电脑随机落子          ...
暖心AI陪你下三子棋.zip
12-06
人工智能陪伴下棋，独单落寞时来一把，帮你找回自我。
用C语言实现三子棋，电脑优化算法；
weixin_42307601的博客
05-29 718
话不多说上代码： 这个三子棋就是对二维数组的一个应用项目，通过电脑生成随机数来控制电脑的下棋，但这样电脑比较笨，通过对电脑算法的优化让电脑更聪明；更多的是平局，也有可能电脑赢哟。 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<time.h> #define ROW...
三子棋电脑优化
2302_76267737的博客
07-26 107
对电脑的优化，无非就是让它长个脑子，有一定的判断能力，想让它“长个脑子”很简单，就像我们判断输赢一样，当电脑发现你差一个棋子就可以赢时，它会来拦截你。可以看出，编写思路与我们编写判断输赢时差不了多少，可以说是对输赢这个结果的一个拦截。对行、列、对角线上即将有三个相同符号组成一条线时做出判断并拦截。上篇博客我们已经进行了三子棋游戏的编写，然而上篇博客中三子棋电脑太笨，从而没有“博弈”之后电脑就可以对你精准的拦截了。所以这篇我们来对电脑进行优化。
编写一个三子棋游戏,和弱智电脑下棋
QuSheng_c的博客
08-21 715
感谢B站大神鹏哥的无私教授
c语言简单实现三子棋（五子棋）
Zhang_1218的博客
07-17 1149
c语言简单实现三子棋（五子棋） 此版本三子棋，我将其命名为三子棋1.0，其特点在于玩家无法赢取电脑，最大可能是和电脑平局，否则就是电脑赢 若想让玩家取胜，也可以。只需将代码中的函数game（）里面玩家的走动放在电脑前面即可，即让玩家先手移动。 话不多说，直接上代码: 1.三子棋： #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _GAME_
快速上手三子棋
m0_65190367的博客
05-19 264
目录 游戏思路 功能细分讲解 游戏菜单： 用户输入： 棋盘的设计： 玩家下棋： 电脑下棋： 判断输赢： 最终代码—工程创建 游戏功能的声明-game.h 测试-test.c 游戏逻辑的实现-game.c 当小伙伴们学完C语言的循环、数组、函数后，就可以完成部分简易的游戏了，无论你基础如何，看完这篇三子棋的手把手讲解，再加上自己勤奋训练，定会进步一大步。 游戏思路 由于玩家玩游戏可能需要玩多次，因此我们可以采用do…while循环实现用户选择菜单的功能； ...
C语言写出三子棋
weixin_68625630的博客
04-28 2323
大家生活中都玩过三子棋，五子棋吧，除了实体的棋盘，想玩的话在小游戏里也是随处可见，那如果自己想写出一个三子棋棋盘，该怎么做呢？用C语言就可以实现，接下来我将详细地描述用C语言写出三子棋的详细过程。 大家应该非常熟悉游戏的界面，通常进入小游戏会有一个界面来让玩家选择是否进入游戏，或者退出游戏，或者选择菜单等等。我们现在简易地实现这个功能即可，如下图： 当我们在键盘上按下1时即进入游戏，按下0即退出游戏，若输入其他则要重新输出； 接下来讲解一下代码是怎么实现的： void menu() { ...
三子棋（N子棋）游戏的保姆级超详细教程（C语言）
m0_70088010的博客
11-11 1565
这是一篇保姆级超详细教程关于如何实现三子棋代码的书写，涉及的细节颇多，玩家需要细细琢磨！
c语言三子棋的实现及拓展
花落因为花开过的博客
08-11 294
目录 前言 1.游戏功能 2.功能实现 1.建立棋盘 1.1棋盘初始化 2.游戏运行 2.1 菜单打印 2.2 玩家下棋 2.3 电脑下棋 2.4判断状态 2.5判断胜负 3.代码模块 4.拓展 前言 三子棋又叫做井字棋、宫字棋，小时候我们无聊时一定都玩过。今天我们便用c语言来实现它！ 1.游戏功能 玩家通过坐标（x,y）将棋子打印在棋盘上，而电脑借用随机生成两个数形成坐标打印。当玩家或电脑下的棋子在横、竖、对角...
三子棋_三子棋_
10-03
三子棋是一款很酷炫的游戏，玩一次就会喜欢上的。
C语言零基础手把手三子棋代码完整版
08-23
C语言零基础手把手三子棋代码完整版，玩家和电脑轮流在3x3的棋盘上下棋，目标是先将自己的棋子连成一行、一列或一条对角线获胜。规定：先连成一条直线（3 个棋子）的玩家获胜，直线是行，列，对角线均可。若在棋盘下...
C语言实现简单三子棋程序
08-27
主要为大家详细介绍了C语言实现简单三子棋程序，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Sanziqi.rar_java 三子棋
09-23
(3) 三子棋。编写程序，实现简单的三子棋游戏。在三子棋中，双方在3*3的棋盘中轮流下棋，一方用*表示，另一方用O表示。如果一方的3个棋子占据了同一行，同一列或者对角线，则该方获胜。如果棋盘已被棋子占满，但没有...
C语言与内存息息相关的重要概念有哪些？
PAP
05-21 496
C语言与内存息息相关的重要概念有哪些？
C++ enum 和 string互转
最新发布
一个大佬的博客
05-28 265
【代码】C++ enum 和 string互转。
C++：round函数用法
Solititude的博客
05-28 221
C++：round函数用法
【最新区块链论文录用资讯】CCF A—INFOCOM 2024 共17篇
软件工程小施同学 的专栏
05-28 897
详情：https://infocom2024.ieee-infocom.org/program/accepted-paper-list-main-conference。BR-DeFedRL：具有快速收敛和通信效率的拜占庭式鲁棒去中心化联邦强化学习。FileDES：一个安全、可扩展、简洁的基于区块链的去中心化加密存储网络。CRACKLE：具有次线性通信复杂性的基于扇区的快速 BFT 共识。通过可逆 GAN 实现高容量的基于区块链的通用隐写术框架。通过树图区块链的半异步去中心化联邦学习框架。
List<Map<String,Integer>> listChessBlack = new ArrayList<Map<String,Integer>>();
10-30
List<Map<String,Integer>> listChessBlack是一个泛型为Map<String,Integer>的ArrayList，用于存储黑棋的位置信息。其中Map<String,Integer>表示一个键值对，键为String类型，值为Integer类型，用于存储棋子的位置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值