基于alpha-beta剪枝的MaxMin算法的中国象棋AI

已于 2024-03-25 12:37:23 修改
阅读量197 收藏 2
点赞数 1
文章标签： 算法 剪枝 机器学习
于 2024-03-25 11:54:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40725880/article/details/137009969
版权 
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
#include<random>
#include<ctime>
#include<windows.h>
#include<omp.h>
#define pll pair<int,int>
using namespace std;
static default_random_engine e;
struct Chess {
    int des[10][9];
};
int maxnumcore;
int maxstep=8;
int thinktime=30;
int nodelimt=7; 
int qzw[32] = {100,3,3,3,3,7,7,15,15,10,10,1,1,1,1,1,-100,-3,-3,-3,-3,-7,-7,-15,-15,-10,-10,-1,-1,-1,-1,-1};
pair<int, int> limx[16] = { {0,2},{0,2},{0,2},{0,4},{0,4},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9},{0,9}};
pair<int, int> limy[16] = { {3,5},{3,5},{3,5},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8},{0,8}};
Chess prec;
class cheess{
public:
    pair<int, int> POS[32];
    Chess base;
    void init() {
        POS[0] = { 0,4 }; POS[1] = { 0,3 }; POS[2] = { 0,5 }; POS[3] = { 0,2 }; POS[4] = { 0,6 };
        POS[5] = { 0,1 }; POS[6] = { 0,7 }; POS[7] = { 0,0 }; POS[8] = { 0,8 }; POS[9] = { 2,1 };
        POS[10] = { 2,7 }; POS[11] = { 3,0 }; POS[12] = { 3,2 }; POS[13] = { 3,4 }; POS[14] = { 3,6 };
        POS[15] = { 3,8 }; POS[16] = { 9,4 }; POS[17] = { 9,5 }; POS[18] = { 9,3 }; POS[19] = { 9,6 };
        POS[20] = { 9,2 }; POS[21] = { 9,7 }; POS[22] = { 9,1 }; POS[23] = { 9,8 }; POS[24] = { 9,0 };
        POS[25] = { 7,7 }; POS[26] = { 7,1 }; POS[31] = { 6,0 }; POS[30] = { 6,2 }; POS[29] = { 6,4 };
        POS[28] = { 6,6 }; POS[27] = { 6,8 };
        for (int i = 0; i < 10; i++)for (int j = 0; j < 9; j++)base.des[i][j] = -1;
        for (int i = 0; i < 32; i++) base.des[POS[i].first][POS[i].second] = i;
        //base.des[6][0]=base.des[6][2]=base.des[6][4]=base.des[6][6]=base.des[6][8]=-1;
        //base.des[3][0]=base.des[3][2]=base.des[3][4]=base.des[3][6]=base.des[3][8]=-1;
    }
    inline Chess rev(Chess& a) {
        Chess k;
        for(int i=0;i<10;i++)for(int j=0;j<9;j++)k.des[i][j]=-1;
        for (int i = 0; i < 10; i++)for (int j = 0; j < 9; j++){
            if(a.des[9 - i][8 - j]>15)k.des[i][j] = a.des[9 - i][8 - j]-16;
            else if(a.des[9 - i][8 - j]>=0)k.des[i][j] = a.des[9 - i][8 - j]+16;
        }
        return k;
    }
    inline int calval(Chess&u){
        int cn=0;
        for(int i=0;i<10;i++)for(int j=0;j<9;j++)
            if(u.des[i][j]>=0)cn+=qzw[u.des[i][j]];
        return cn;
    }
    inline Chess Creatdes(int posxi, int posyi, int posx, int posy, Chess p) {
        int i = p.des[posxi][posyi];
        p.des[posx][posy] = i;
        p.des[posxi][posyi] = -1;
        return rev(p);
    }
    inline int judge(Chess& u, int i, int posx, int posy) {
        if (i == 0 && u.des[posx][posy] == 16)return 1;
        if (!(limx[i].first <= posx && posx <= limx[i].second && limy[i].first <= posy && posy <= limy[i].second))return 0;
        if (!(u.des[posx][posy] == -1 || u.des[posx][posy] > 15))return 0;
        return 1;
    }
    inline vector<Chess> step(Chess tmp, int sw) {
        pair<int, int> poi[32];
        for (int i = 0; i < 32; i++)poi[i] = { -1,-1 };
        for (int i = 0; i < 10; i++)for (int j = 0; j < 9; j++)if (tmp.des[i][j] >= 0)poi[tmp.des[i][j]] = { i,j };
        vector<Chess> ans;
 
        int nposx, nposy, posx, posy;
        auto work = [&](int i)-> void {
            if (judge(tmp, i, nposx, nposy))
                ans.push_back(Creatdes(posx, posy, nposx, nposy, tmp));
        };
        for (int i = 0; i <= 15; i++) {
            if(sw==0)i=e()%16;
            if (poi[i].first == -1)continue;
            posx = poi[i].first, posy = poi[i].second;
            if (i == 0) {
                nposx = posx - 1, nposy = posy;
                work(i);
                nposx = posx + 1, nposy = posy;
                work(i);
                nposx = posx, nposy = posy + 1;
                work(i);
                nposx = posx, nposy = posy - 1;
                work(i);
                if (posy == poi[16].second) {
                    nposx = poi[16].first, nposy = poi[16].second;
                    int x=0;
                    for(int j=posx+1;j<=nposx-1;j++)if(tmp.des[j][posy]!=-1)x=1;
                    if(x==0){
                        work(i);
                        
                    }
                }
            }
            else if (i == 1 || i == 2) {
                nposx = posx - 1, nposy = posy - 1;
                work(i);
                nposx = posx + 1, nposy = posy + 1;
                work(i);
                nposx = posx - 1, nposy = posy + 1;
                work(i);
                nposx = posx + 1, nposy = posy - 1;
                work(i);
            }
            else if (i == 3 || i == 4) {
                if (posx - 1 >= 0 && posy - 1 >= 0 && tmp.des[posx - 1][posy - 1] == -1) {
                    nposx = posx - 2, nposy = posy - 2;
                    work(i);
                }
                if (posx + 1 <= 9 && posy + 1 <= 8 && tmp.des[posx + 1][posy + 1] == -1) {
                    nposx = posx + 2, nposy = posy + 2;
                    work(i);
                }
                if (posx + 1 <= 9 && posy - 1 >= 0 && tmp.des[posx + 1][posy - 1] == -1) {
                    nposx = posx + 2, nposy = posy - 2;
                    work(i);
                }
                if (posx - 1 >= 0 && posy + 1 <= 8 && tmp.des[posx - 1][posy + 1] == -1) {
                    nposx = posx - 2, nposy = posy + 2;
                    work(i);
                }
            }
            else if (i == 5 || i == 6) {
                if (posx - 1 >= 0 && tmp.des[posx - 1][posy] == -1) {
                    nposx = posx - 2, nposy = posy - 1;
                    work(i);
                    nposx = posx - 2, nposy = posy + 1;
                    work(i);
                }
                if (posx + 1 <= 9 && tmp.des[posx + 1][posy] == -1) {
                    nposx = posx + 2, nposy = posy + 1;
                    work(i);
                    nposx = posx + 2, nposy = posy - 1;
                    work(i);
                }
                if (posy - 1 >= 0 && tmp.des[posx][posy - 1] == -1) {
                    nposx = posx - 1, nposy = posy - 2;
                    work(i);
                    nposx = posx + 1, nposy = posy - 2;
                    work(i);
                }
                if (posy + 1 <= 8 && tmp.des[posx][posy + 1] == -1) {
                    nposx = posx - 1, nposy = posy + 2;
                    work(i);
                    nposx = posx + 1, nposy = posy + 2;
                    work(i);
                }
            }
            else if (i == 7 || i == 8) {
                for (int j = 1; j <= 9; j++) {
                    nposx = posx + j, nposy = posy;
                    work(i);
                    if (posx + j > 9 || tmp.des[posx + j][posy] != -1)break;
                }
                for (int j = 1; j <= 9; j++) {
                    nposx = posx - j, nposy = posy;
                    work(i);
                    if (posx - j < 0 || tmp.des[posx - j][posy] != -1)break;
                }
                for (int j = 1; j <= 8; j++) {
                    nposx = posx, nposy = posy + j;
                    work(i);
                    if (posy + j > 8 || tmp.des[posx][posy + j] != -1)break;
                }
                for (int j = 1; j <= 8; j++) {
                    nposx = posx, nposy = posy - j;
                    work(i);
                    if (posy - j < 0 || tmp.des[posx][posy - j] != -1)break;
                }
            }
            else if (i == 9 || i == 10) {
                for (int j = 1; j <= 9; j++) {
                    if (posx + j > 9)break;
                    if (tmp.des[posx + j][posy] == -1) {
                        nposx = posx + j, nposy = posy;
                        work(i);
                    }
                    if (tmp.des[posx + j][posy] != -1) {
                        j++;
                        while (posx + j <= 9 && tmp.des[posx + j][posy] == -1)j++;
                        nposx = posx + j, nposy = posy;
                        work(i);
                        break;
                    }
                }
                for (int j = 1; j <= 9; j++) {
                    if (posx - j < 0)break;
                    if (tmp.des[posx - j][posy] == -1) {
                        nposx = posx - j, nposy = posy;
                        work(i);
                    }
                    if (tmp.des[posx - j][posy] != -1) {
                        j++;
                        while (posx - j >= 0 && tmp.des[posx - j][posy] == -1)j++;
                        nposx = posx - j, nposy = posy;
                        work(i);
                        break;
                    }
                }
                for (int j = 1; j <= 8; j++) {
                    if (posy + j > 8)break;
                    if (tmp.des[posx][posy + j] == -1) {
                        nposx = posx, nposy = posy + j;
                        work(i);
                    }
                    if (tmp.des[posx][posy + j] != -1) {
                        j++;
                        while (posy + j <= 8 && tmp.des[posx][posy + j] == -1)j++;
                        nposx = posx, nposy = posy + j;
                        work(i);
                        break;
                    }
                }
                for (int j = 1; j <= 8; j++) {
                    if (posy - j < 0)break;
                    if (tmp.des[posx][posy - j] == -1) {
                        nposx = posx, nposy = posy - j;
                        work(i);
                    }
                    if (tmp.des[posx][posy - j] != -1) {
                        j++;
                        while (posy - j >= 0 && tmp.des[posx][posy - j] == -1)j++;
                        nposx = posx, nposy = posy - j;
                        work(i);
                        break;
                    }
                }
            }
            else {
                nposx = posx + 1, nposy = posy;
                work(i);
                if (posx > 4) {
                    nposx = posx, nposy = posy + 1;
                    work(i);
                    nposx = posx, nposy = posy - 1;
                    work(i);
                }
            }
            if(sw==0&&ans.size())return ans;
        }
        return ans;
    }
    inline int Checkend(Chess &u){
        int x=1;
        for(int i=limx[0].first;i<=limx[0].second;i++)
            for(int j=limy[0].first;j<=limy[0].second;j++)
                if(u.des[i][j]==0)x=0;
        return x;
    }
    int rollout(Chess u,int dep) {
        int ans = 0;
        if (Checkend(u)) {
            return 1e9;
        }
        for (int tp = 1; tp <= thinktime; tp++) {
            auto tmp = u;
            int cnt = maxstep - dep;
            int lun=1;
            while (cnt>=0) {
                vector<Chess> mulp;
                while(mulp.size()<1)mulp=step(tmp,0);
                int fe = 1;
                lun=!lun;
                for (auto& v : mulp) {
                    if(!Checkend(v))continue;
                    if (lun==0)ans += calval(v);
                    else ans-=calval(v);
                    fe=0;
                }
                if(fe==0)break;
                random_shuffle(mulp.begin(), mulp.end());
                tmp=mulp.back();
                cnt--;
                
                if(cnt<0){
                    if (lun==0)ans += calval(tmp);
                    else ans-=calval(tmp);
                }
            }
        }
        return ans;
    }
    int maxn=-1e9;
    Chess ans;
    int nay=0;
    /*a:前面最大已经取到了a，b:前面最小已经取到了b*/
    /*在MAX层，如果前面最小都已经取到b了，你在这层大于b可以直接退出*/
    /*在MIN层，如果前面最大都已经取到a了，你在这层小于a可以直接退出*/
    int cnt=0;
    int abcut(Chess u,int dep,int a,int b,int lun){
        //cnt++;
        //cout<<cnt<<'\n';
        
        if(dep==maxstep||Checkend(u)){
            if(lun==0)return calval(u);
            else return -calval(u);
        }
        vector<Chess> snf=step(u, 1);
        vector<int> roaval(snf.size());
        vector<pair<int,int>> p; 
#pragma omp parallel for num_threads(maxnumcore)
        for(int i=0;i<snf.size();i++){
            auto&v=snf[i];
            roaval[i]=rollout(v,dep+1);
        }
        for(int i=0;i<roaval.size();i++)
            p.push_back({roaval[i],i});
        sort(p.begin(), p.end(),greater<pll>());
        for(int i=0;i<nodelimt&&i<snf.size();i++){
            if(dep==0)nay++,cout<<nay<<'\n';
            auto&v=snf[p[i].second];
            int tmp=abcut(v,dep+1,a,b,!lun);
            if(dep==0&&tmp>maxn){
                maxn=tmp;
                ans=v;
            }
            if(lun==0)a=max(tmp,a);
            else b=min(tmp,b);
            if(a>=b)break;
        }
        if(lun==0)return a;
        else return b;
    }
    inline void sendmessage(int rx,int ry,int px,int py){
        ofstream outFile;
        outFile.open("rec.txt", std::ios::out);
		outFile << rx<<' '<<ry<<'\n';
        outFile << px<<' '<<py<<'\n';
		outFile.close();
        outFile.open("message.txt", std::ios::out);
        outFile<<1<<'\n';
        outFile.close();
    }
    void cp() {
        Chess now=base,tmp;
        prec=base;
        while (1) {
            tmp=now;

            maxn=-1e9;
            nay=0,cnt=0;
            abcut(now,0,-1e9,1e9,0);
            now = ans;

            prec=tmp;
            tmp=rev(now);
            int readx,ready,px,py;
            for(int i=0;i<10;i++)for(int j=0;j<9;j++)if(prec.des[i][j]!=tmp.des[i][j]){
                if(tmp.des[i][j]!=-1){
                    px=i,py=j;
                }
                else readx=i,ready=j;
            }
            sendmessage(readx,ready,px,py);

            if(Checkend(now)){
                cout<<"ERO!!!!!!!!!!!!\n";
                system("pause");
                break;
            }

            tmp=now;

            maxn=-1e9;
            nay=0,cnt=0;
            abcut(now,0,-1e9,1e9,0);
            now = ans;

            prec=rev(tmp);
            tmp=now;
 
            for(int i=0;i<10;i++)for(int j=0;j<9;j++)if(prec.des[i][j]!=tmp.des[i][j]){
                if(tmp.des[i][j]!=-1){
                    px=i,py=j;
                }
                else readx=i,ready=j;
            }
            sendmessage(readx,ready,px,py);
            if(Checkend(now)){
                cout<<"ERO!!!!!!!!!!!!\n";
                system("pause");
                break;
            }
        }
    }
}tester;
int main()
{
    //ios::sync_with_stdio(0);
    cin.tie(0);
    maxnumcore = omp_get_num_procs();
    tester.init();
    e.seed(time(0));
    while (1) {
        tester.cp();
    }
    while(1);
    return 0;
}

Hirro_
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
人工智能---Alpha-Beta剪枝（中国象棋）
MJ_GOD
02-11 1万+
文章目录导言实验过程结果分析结论代码主要参考文献 摘要：本次实验我们基于Alpha-Beta剪枝算法设计了一个中国象棋博弈程序， 并综合考虑了棋力，攻击能力，保护能力多种因素设计了棋局的静态评估函数。通过实验结果反映出该静态评估函数的设计能够比较好地引导程序进行攻击和防守，在深度为2的搜索树上取得了比较好的效果。 导言 尽管目前五子棋，国际象棋，围棋等博弈程序已经取得了较大成功，但是中国象棋...
C程序设计（第五版）谭浩强 学习笔记—重点及易错点（1-5章）
热门推荐
lwbCUMT的博客
09-07 2万+
第一章 程序设计与C语言 目录 第一章 程序设计与C语言 一、计算机语言的发展 二、C语言的注释方法 三、程序设计任务 第二章 算法—程序的灵魂 一、程序的组成 二、结构化程序设计的方法 第三章 最简单的C程序设计—顺序程序设计 一、数据类型 二、运算符与表达式 三、数据的输入和输出 第四章 选择结构与条件判断 第五章 循环结构程序设计 第六章 利用数组处理批量数据 ...
谭浩强C程序设计(第五版)知识点整理
u014363023的博客
12-28 8006
谭浩强C程序设计(第五版)主要知识点整理(for中南财837)
C语言程序设计 第五版 谭浩强 知识点汇总+复习
Malus的博客
01-07 2719
C程序设计 复习
【谭浩强C程序设计精讲 7】数据的输入输出
最新发布
自强不息怀壮志以长行，厚德载物携梦想而抚凌。
01-12 1969
资深一线科研型教师带你一起温故C程序设计。本文重点介绍数据的输入输出相关知识，包括格式输入输出函数和字符输入输出函数，格式字符和附加格式字符详解。
[人工智能]alpha-beta剪枝算法及实践.pdf
02-27
【人工智能】Alpha-Beta剪枝算法是用于解决博弈树搜索问题的一种优化方法，特别是在棋类游戏AI中广泛应用。它是极大极小搜索算法的改进版，旨在提高搜索效率，减少不必要的计算分支。 **算法原理** Alpha-Beta剪枝...
Scratch作品：中国象棋AI( 采用了alphabeta 剪枝算法 )
04-05
主要使用算法： maxmin 极大极小值搜索 alphabeta 剪枝算法( 与阿尔法围棋 AlphaGo 一样的算法 )，可进行 AI 人机对决。 注：使用AI算法比较复杂，1500+的代码计算起来会很慢。使用turbowarp编译可以大幅度提升速度...
C++使用MFC基于Minimax算法和&alpha;-&beta;剪枝的五子棋AI（带图形界面）
02-19
《C++与MFC结合实现五子棋AI：基于Minimax算法与&alpha;-&beta;剪枝》 五子棋是一款深受大众喜爱的智力游戏，而利用计算机编程实现五子棋的人工智能(AI)则需要深入理解博弈论和优化算法。本项目采用C++语言，并结合Microsoft...
AI-Chess：算法项目：使用minmax算法和alpha beta修剪的AI Chess Engine
02-16
人工智能的国际象棋情报估计为9级中的3级。极小极大算法从Wikipedia的简洁定义中借用的是“用于最小化最坏情况（最大损失）情况下可能的损失的决策规则”。 对于国际象棋，扮演角色的玩家是最大化者，其移动将受到...
中国象棋AI算法 C/C++
10-21
中国象棋AI算法是计算机科学领域中的一个重要分支，特别是在游戏开发和人工智能研究中。这篇教程主要关注的是使用C/C++编程语言实现的中国象棋AI算法。以下将详细阐述这个主题涉及的知识点。 1. **基础算法理论**：...
C++程序设计--谭浩强（完整版）
10-19
本文档适合广大的一线教师及有需要的C++小白，有需要的拿去，不谢！
谭浩强 C++程序设计(第三版)课件
01-08
C++程序设计，谭浩强，第三版最新PPT课件，跟教材配套的。。。
C程序设计(谭浩强)第三版.rar
05-24
C程序设计(谭浩强)第三版，包括ppt和教材源码。完整，入门c的第一本教材
谭浩强c语言程序设计练习习题集
03-27
c语言程序设计谭浩强版的练习题集收录
谭浩强第四版答案
03-28
谭浩强第四版c语言答案，内容详细，作为入门必看书籍，课后答案对读者有着十分重要的意义与作用，能够参考代码并且学习利用。
如何评价谭浩强（转自知乎）
SeedCoder2014
03-28 4062
一些同学学不好C语言，把罪责归于“因为教材是谭浩强写的”实在是很滑稽。 谭浩强老先生 1934 年生，现在已经 80 岁了。他 1958 年从清华大学自动控制系毕业，那年 24 岁。要知道 C 语言那时候都还没诞生，计算机都是大型机，原始又笨重，当时谭浩强学自动化控制这一专业可以说是比较尖端的。光从这一点上，就可以说，他是同时代人里非常非常聪明的那一类人。 现在许多人批评谭浩强的《C
为什么很多人吐槽谭浩强的C语言程序设计，端碗吃饭放碗骂娘？
04-27 1460
这个观点在网络上已经论战了很长时间，出现这种情况还是历史遗留问题，谭浩强出的C语言教材几乎是国内的第一版，由于中英翻译问题或者对编程文化理解的差异性导致出来的书多多少少存在一些纰漏。不能只是记住其缺点，谭浩强书最主要在那个年代起到了普及C语言的作用，这已经足够了，如同做一个产品，首先解决的是有没有问题，最后才是细节完善阶段。 如同历史上发生了许多在今天看来很搞笑的事情，社会...
C++程序设计（谭浩强PDF）
05-10
本资源为谭浩强C++程序设计PDF版本，资源分为章节介绍，提取了更加精炼的内容，资料中的源码资源可以在搜索“C++程序设计（谭浩强版+源码）”
Alpha-beta剪枝算法和Min-Max剪枝算法的区别
04-28
1. Alpha-beta剪枝算法是基于Min-Max剪枝算法的改进版，它利用局面的上下界信息来剪枝，从而减少搜索的节点数，提高搜索效率。 2. 在Min-Max剪枝算法中，对于每个节点，都会考虑其所有子节点，直到搜索到叶子节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值