使用js求解并展示华容道的步骤

最新推荐文章于 2023-05-01 22:12:27 发布
最新推荐文章于 2023-05-01 22:12:27 发布
阅读量729 收藏 3
点赞数 1
分类专栏： 乱 文章标签： js javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38036099/article/details/111885785
版权

使用js求解华容道的步骤

概述

用一个大小为20的数组表示地图。
地图中有两个空格，空格可以上下左右四个方向。每个地图有八种移动情况。
初始化一个队列，放进去初始的地图。
从队列取出第一个地图，然后尝试这八种情况，把可行的放到队列里。依此类推，直到成功。
运行结果

代码

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>华容道练习20201228</title>
</head>
<style>
    td{
        padding: 0.4em;
    }
    table{
        float: left;
        margin: 4px;
    }
</style>
<body>
<div id="msgDiv">华容道</div>
<br/>
<button id="btn1" onclick="getBestPath()">求解</button>
<span id="info" style="display: none;">用时:<span id="useTime"></span>ms, 步骤：<span id="stepNum"></span>步 <span style="opacity: 0.6;float: right;"> &nbsp; (尝试了：<span id="count"></span>次)</span></span>
<br/>
<div style="clear: both;"></div>
<script type="text/javascript">
/*
地图宽4，高5； 用连续的20个数表示地图； 
        0000 代表当前位置的点与相邻的点没有关系，
        1000 代表与上边的点连接
        0100 代表与右边的点连接
        .... 依次类推，上右下左
表示点的数字
    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15].map(v=>v.toString(2))
    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15].map(v=>""+((v>>3)&1)+((v>>2)&1)+((v>>1)&1)+((v>>0)&1))
    { 0: "0000", 1: "0001", 2: "0010", 3: "0011",
      4: "0100", 5: "0101", 6: "0110", 7: "0111",
      8: "1000", 9: "1001", 10: "1010",11: "1011",
      12: "1100",13: "1101",14: "1110",15: "1111" }
偏移量：
    [0,1,2,3].map(v=>{ return {x:v&1,y:(v&2)>>1} }) // 
表示点的数字 与 它对应的 相邻的点的偏移量们
    JSON.stringify([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15].map(v=>{
        var arr=[];
        if((v>>3)&1) arr.push([0,-1]);
        if((v>>2)&1) arr.push([1,0]);
        if((v>>1)&1) arr.push([0,1]);
        if((v>>0)&1) arr.push([-1,0]);
        return arr;
    })) // const NEAR_SKEWS = ...
    JSON.stringify([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15].map(v=>{
        var arr=[];
        if((v>>3)&1) arr.push([0,-1]);
        if((v>>2)&1) arr.push([1,0]);
        if((v>>1)&1) arr.push([0,1]);
        if((v>>0)&1) arr.push([-1,0]);
        if(arr.length>2) return null; // 不处理复杂的
        if(arr.length===2) arr.push([arr[0][0]+arr[0][1],arr[1][0]+arr[1][1]]);
        return arr;
    })) // const NEAR_POINT_SKEWS

*/
    
	console.log("华容道练习");

    /**
     * 定义一些常量，也可以定义到 Cmp 中
     */
    const EMPS_LEN = 2, EMPS_LEN_HALF = 1; // 常量，两个空格, 2的一半是1
    const WIDTH = 4, HEIGHT = 5; // 地图大小
    const CHAR_NUM_MP = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,"a":10,"b":11,"c":12,"d":13,"e":14,"f":15}; // 字符 : 数字
    const NUM_CHAR_ARR = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];
    // 根据点的数字，确定相邻的点基于当前的点的坐标的偏移量
    const NEAR_SKEWS = [[],[[-1,0]],[[0,1]],[[0,1],[-1,0]],[[1,0]],[[1,0],[-1,0]],[[1,0],[0,1]],[[1,0],[0,1],[-1,0]],[[0,-1]],[[0,-1],[-1,0]],[[0,-1],[0,1]],[[0,-1],[0,1],[-1,0]],[[0,-1],[1,0]],[[0,-1],[1,0],[-1,0]],[[0,-1],[1,0],[0,1]],[[0,-1],[1,0],[0,1],[-1,0]]]; 
    // 针对当前这个地图做的一个特殊的数组，存放了点的数字 对应着的物体中的所有点
    const NEAR_POINT_SKEWS = [[],[[-1,0]],[[0,1]],[[0,1],[-1,0],[1,-1]],[[1,0]],[[1,0],[-1,0],[1,-1]],[[1,0],[0,1],[1,1]],[null],[[0,-1]],[[0,-1],[-1,0],[-1,-1]],[[0,-1],[0,1],[-1,1]],[null],[[0,-1],[1,0],[-1,1]],[null],[null],[null]];
    const EMP_CHAR = 'f', EMP_NUM = 15; // 表示空白的字符，常用。 1111 。
    const TOP_NUM = 8, RIGHT_NUM = 4, BOTTOM_NUM = 2, LEFT_NUM = 1; // 上右下左 // 1000, 0100, 0010, 0001
    // 下面四个是一组 ，（为了遍历空格的四周而服务）
    const SKEWS_XY = [[0,-1],[1,0],[0,1],[-1,0]]; // 偏移量，上右下左
    const SKEWS_NUM = [TOP_NUM, RIGHT_NUM, BOTTOM_NUM, LEFT_NUM]; // 标记物体方向，上右下左
    const MOVE_XY = [[0,1],[-1,0],[0,-1],[1,0]]; // 偏移量，下左上右
    // const MOVE_NUM = [BOTTOM_NUM, LEFT_NUM , TOP_NUM, RIGHT_NUM]; // 标记移动方向，下左上右
    var numToChar = function(num){return NUM_CHAR_ARR[num];};
	// 一个地图状态 
	function Cmp(mpNums,emps,parentMp,count){ // 地图数组，空格的位置，父Cmp，计数
        this.mpStr = mpNums.map(numToChar).join("");
        this.mpNums = mpNums;
        // [(x1,y1),(x2,y2)] 表示空格的位置 // 注意：不能修改内部的数组里面的值
        this.emps = emps; 
		// 最小的步数
		this.count = count;
		// count最小的父状态
        this.parentMp = parentMp;
        // this.childMps = null; // 记录子mps，如果可行的话 [[子mps],] 子mps按照count从小到大排列
    }
    // 是否符合条件
    Cmp.prototype.isOk = function(){
        // return this.mpStr[1+4*3]=="0110" && this.mpStr[2+4*3]=="0011" && this.mpStr[1+4*4]=="1100" && this.mpStr[2+4*4]=="1001";
        return this.mpStr[13]=="6";//只用判断这一个就行；  && this.mpStr[14]=="3" && this.mpStr[17]=="c" && this.mpStr[18]=="9";
    }
    // 是否对称
    Cmp.prototype.is对称 = (function(){
        var relMp = {
            "6":"3", "3":"6", 
            "c":"9", "9":"c", 
            "4":"1", "1":"4"
        };
        return function (){
            return this.mpStr[0]===this.mpStr[3] && 
                    this.mpStr[4]===this.mpStr[7] && 
                    this.mpStr[8]===this.mpStr[11] && 
                    this.mpStr[12]===this.mpStr[15] && 
                    this.mpStr[16]===this.mpStr[19] && 
                    (this.mpStr[1]===this.mpStr[2] || this.mpStr[1]===relMp[this.mpStr[2]]) && 
                    (this.mpStr[5]===this.mpStr[6] || this.mpStr[5]===relMp[this.mpStr[6]]) && 
                    (this.mpStr[9]===this.mpStr[10] || this.mpStr[9]===relMp[this.mpStr[10]]) && 
                    (this.mpStr[13]===this.mpStr[14] || this.mpStr[13]===relMp[this.mpStr[14]]) && 
                    (this.mpStr[17]===this.mpStr[18] || this.mpStr[17]===relMp[this.mpStr[18]]);
        }
    })();
    // 获取地图中的点信息
    Cmp.prototype.getCharAt = function(x,y){
        if(x===-1||x===WIDTH||y===-1||y===HEIGHT)return undefined;
        return this.mpStr[ x + y*WIDTH ];
    };
    Cmp.prototype.getIntAt = function(x,y){
        if(x===-1||x===WIDTH||y===-1||y===HEIGHT)return undefined; // 必须要加判断，不然后出错
        return this.mpNums[ x + y*WIDTH ];
    };
    // 拷贝数组
    Cmp.prototype.copyNums = function(){
        return this.mpNums.slice();
    }
    Cmp.prototype.copyEmps = function(){
        return this.emps.slice();
    }
    // 将地图转化为表格
    Cmp.prototype.toDomTable = function(){
        var table = document.createElement("table"), tr, td;
        table.border=1; table.cellSpacing=1;
        var x,y,tNum;
        var pmp=this.parentMp;
        for(y=0;y<HEIGHT;y++){
            tr = document.createElement("tr");
            for(x=0;x<WIDTH;x++){
                td = document.createElement("td");
                tNum = this.getIntAt(x,y);
                if(pmp!==null){
                    if(pmp.getIntAt(x,y) != tNum) td.style.backgroundColor="gold";
                }
                if(tNum === EMP_NUM){
                    td.style.border         = "1px solid white";
                } else {
                    td.style.borderTop      = (tNum & TOP_NUM)      ? "1px solid white" : "1px solid black";
                    td.style.borderRight    = (tNum & RIGHT_NUM)    ? "1px solid white" : "1px solid black";
                    td.style.borderBottom   = (tNum & BOTTOM_NUM)   ? "1px solid white" : "1px solid black";
                    td.style.borderLeft     = (tNum & LEFT_NUM)     ? "1px solid white" : "1px solid black";
                }
                tr.appendChild(td);
            }
            table.appendChild(tr);
        }
        return table;
    }
    // 获取下一步的地图；第i个空格，空格的移动方向为 j
    Cmp.prototype.next = function(i,j){ // 如果无法移动，返回null
        var cmp2 = null; // 下一步地图
        var x       =   this.emps[i][0], 
            y       =   this.emps[i][1]; // 空格的坐标
        var sx      =   SKEWS_XY[j][0], 
            sy      =   SKEWS_XY[j][1]; // 相对于空格的位置
        var sNum    =   SKEWS_NUM[j]; // 相对于空格的位置
        var px      =   x + sx, 
            py      =   y + sy; // 要移动的点的坐标
        var pNum = this.getIntAt(px,py); // 要移动的点的num
        if( pNum === undefined ) return cmp2; // 越界了
        var aNum,bNum,cNum,dNum; // 临时变量
        // 判断能否移动成功
        if(pNum !== EMP_NUM){ // 不能挨着空格，因为空格不能移动
            var tNums = this.copyNums(); // 地图Nums的拷贝
            var tnps = NEAR_POINT_SKEWS[pNum]; // 点相邻的点们
            var tEmps = this.copyEmps(); // 点坐标的浅拷贝
            if(pNum === 0){ // 挨着小兵
                tNums[x+y*WIDTH]=pNum; // 直接交换
                tNums[px+py*WIDTH]=EMP_NUM;
                tEmps[i] = [px,py];// 更新空格的位置
                cmp2 = new Cmp(tNums,tEmps,this,this.count+1);
            } else if(pNum === sNum){ // 挨着条状的，且跟移动方向一条直线的，可以移动
                aNum = x+y*WIDTH; // 空格
                bNum = px+py*WIDTH; // 点
                cNum = (px+sx) + (py+sy) * WIDTH; // 另一个点
                tNums[aNum]=pNum;
                tNums[bNum]=tNums[cNum];
                tNums[cNum]=EMP_NUM;
                tEmps[i] = [(px+sx),(py+sy)];// 更新空格的位置 // 这儿其实不用new一个数组
                cmp2 = new Cmp(tNums,tEmps,this,this.count+1);
            } else if(tnps.length===1){ // 挨着条状的，且跟移动方向不在一条直线，
                if(this.getIntAt(x+tnps[0][0],y+tnps[0][1]) === EMP_NUM){ // 判断空格旁边是否也是空格
                    // 可以移动
                    aNum = x+y*WIDTH; // 当前空格
                    bNum = px+py*WIDTH; // 挨着的点
                    cNum = (px+tnps[0][0]) + (py+tnps[0][1]) * WIDTH; // 另一个点
                    dNum = (x+tnps[0][0]) + (y+tnps[0][1]) * WIDTH; // 另一个空格
                    tNums[aNum]=pNum;
                    tNums[bNum]=EMP_NUM;
                    tNums[dNum]=tNums[cNum];
                    tNums[cNum]=EMP_NUM;
                    tEmps[i] = [px,py]; // 更新空格的位置
                    tEmps[1-i] = [(px+tnps[0][0]),(py+tnps[0][1])]; // 另一个空格
                    cmp2 = new Cmp(tNums,tEmps,this,this.count+1);
                }
            }else{ // 曹操 //这儿的 tnps.length === 3
                var x2 = this.emps[1-i][0]; // 另一个空格挨着的点
                var y2 = this.emps[1-i][1];
                if((aNum=this.getIntAt(x2+sx,y2+sy))!==undefined && NEAR_POINT_SKEWS[aNum].length===3){ // 判断另一个空格是否也挨着曹操
                    aNum = x+y*WIDTH; // 空格
                    bNum = px+py*WIDTH; // 点
                    cNum = (px+sx) + (py+sy) * WIDTH; // 另一个点
                    tNums[aNum]=tNums[bNum];
                    tNums[bNum]=tNums[cNum];
                    tNums[cNum]=EMP_NUM;
                    tEmps[i] = [(px+sx),(py+sy)];// 更新空格的位置 // 这儿其实不用new一个数组
                    
                    aNum = x2+y2*WIDTH; // 空格2
                    bNum = (x2+sx)+(y2+sy)*WIDTH; // 点2
                    cNum = (x2+sx+sx) + (y2+sy+sy) * WIDTH; // 另一个点2
                    tNums[aNum]=tNums[bNum];
                    tNums[bNum]=tNums[cNum];
                    tNums[cNum]=EMP_NUM;
                    tEmps[1-i] = [(x2+sx+sx),(y2+sy+sy)];// 更新空格的位置 // 这儿其实不用new一个数组
                    
                    cmp2 = new Cmp(tNums,tEmps,this,this.count+1);
                }
            }
        }
        return cmp2;
    }

	// 最开始的地图
	var mpNums = [
		"0010","0110","0011","0010", // 2632
		"1000","1100","1001","1000", // 8c98
		"0010","0100","0001","0010", // 2412
		"1000","0000","0000","1000", // 8008
		"0000","1111","1111","0000", // 0ff0
	].map(function(v){
		return parseInt(v,2);//.toString(16);
    }); // 26328c98241280080ff0
    var startCmp = new Cmp(mpNums,[[1,4],[2,4]],null,0);
    // 清空界面
	function clear(){
        var tables = document.getElementsByTagName("table");
        for(var i=tables.length-1;i>=0;i--){ // 清空table
            document.body.removeChild(tables[i]);
        }
    }
    // 打印地图
    function print(cmp){
        if(cmp) {
            var tt = cmp.toDomTable();
            document.body.appendChild(tt);
        }
    }
    function getBestPath(){
        document.getElementById("btn1").setAttribute("disabled",true);
        var time0 = new Date(), count = 0;

        var stateMp={},i=j=ij=0,DEATH_MP={},OK_MP={},PATH_MP={},mps=[startCmp],cmp,cmp2;
        while(mps.length){
            count++;
            i = ij>>2;
            j = ij&3;
            // 从队列里拿出来一个
            cmp = mps[0];
            cmp2 = cmp.next(i,j);
            if(cmp2 !== null){
                if(stateMp[cmp2.mpStr] === undefined){
                    stateMp[cmp2.mpStr] = PATH_MP;
                    cmp2.parentMp = cmp;
                    cmp2.count = cmp.count+1;
                    if(cmp2.isOk())break;
                    mps.push(cmp2);
                }
            }
            ij++;
            if(ij===8){
                ij=0;
                mps.shift();
            }
        }
        var time1 = new Date();
        document.getElementById("useTime").innerText = time1-time0;
        cmp = cmp2;
        mps.length = 0;
        mps.push(cmp);
        while(cmp=cmp.parentMp){
            mps.push(cmp);
        }
        document.getElementById("stepNum").innerText = mps.length;
        document.getElementById("count").innerText = count;
        document.getElementById("info").style.display = "inline";
        while(cmp=mps.pop()){
            print(cmp);
        }
    }

</script>
</body>
</html>
shuo-shu
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript实现华容道游戏(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-29 336
JavaScript实现华容道游戏(附完整源码)
CreateJS实现【益智类数字华容道小游戏】
止于至善
08-19 1287
由于代码较多，如果需要源代码，请联系我！！！CreateJS 是一个 HTML5游戏开发的引擎，这一篇是入门开发的游戏，还有很多不足，请大神指教！既然是使用 CreateJS 开发游戏，因此游戏界面全部使用 CreateJS 开发，不要还是按照前端的思维，使用div等去布局。能够看到这里的大佬，请++关注，支持一下！！！
华容道游戏破解javascript版
robinspada的博客
03-09 1930
参见下面的文章，华容道用C#写出破解后，感觉程序实在是简单，于是尝试移植到其他语言上http://blog.csdn.net/robinspada/article/details/79354500仅仅是简单移植，没有特别优化，运行时间如下刚开始使用数组的indexOf来去重，结果发现很慢，最快也要7秒以上，大概是用的顺序查找没有使用哈希表的缘故看来还是Chrome更牛一些，不过没有达到一骑绝尘 f...
JS自制简易版数字华容道小游戏
泡锅的博客
03-23 5689
JS自制简易版数字华容道小游戏 最近复习了下前端基础知识HTML+JS（是真的非常基础那种，久不用，基本忘完了）。 复习了一小部分内容，闲暇之余打算利用刚复习的js基础知识做个小游戏，刚好手机上下载的游戏集中就有一个数字益智游戏——数字华容道，个人感觉这游戏还是挺不错的，工作之余或者饭后可以耍一耍，动动脑子老的快。哈哈哈。 数字华容道游戏界面就是一个九宫格的形式（3x3就是标准的九宫格，但是还有4x4、5x5、6x6等），在这些小方格中均有一块写有数字的卡片，从左到右从上到下依次递增，最后一个小方格是
用js做一个数字华容道
void_and_sans的博客
12-25 506
用js做游戏
数字华容道
02-26
纯js写的 数字华容道 游戏，可以设置 3X3，4X4，5X5 几个版本，有自动及时，大家可以看看。
华容道游戏求解最少步骤C++
01-06
【华容道游戏求解最少步骤C++】 华容道是一款经典的棋盘益智游戏，源于中国的三国时期，玩家需要通过移动棋子帮助曹操从起点移动到出口，目标是在尽可能少的步骤内解决谜题。在编程领域，实现华容道的最少步骤求解...
c#实现三国华容道的求解路线与窗体路线演示
12-31
本文将深入探讨如何使用C#编程语言，实现华容道的求解算法及动态演示功能。 首先，我们要了解华容道的基本规则。游戏面板上，各个棋子代表三国时期的人物，目标是通过移动棋子，让曹操从起点到达出口。游戏的关键...
华容道求解及求解步骤动态显示
07-14
《华容道求解及求解步骤动态显示》 华容道，源于中国的传统益智游戏，灵感来自于三国时期曹操逃脱华容道的故事。它是一款二维平面拼图游戏，目标是通过移动各种形状的木块，使特定的目标木块（通常是曹操）从设定的...
华容道求解C语言版，求解效率极高
11-18
本文将深入探讨使用C语言实现华容道求解的高效算法，以及涉及的数据结构和内存管理。 一、C语言基础 C语言是一种强大的、高效的编程语言，它的执行速度极快，是编写底层算法的理想选择。在华容道求解程序中，C语言...
js实现数字拼图游戏
05-27
用JS实现的图片数字拼图！实现方法相当精炼！
jQuery实现数字华容道小游戏(实例代码)
10-15
主要介绍了jQuery实现数字华容道小游戏功能，本文给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
huarongdao：数字华容道H5小游戏
02-16
华容道 数字华容道H5小游戏 开始学习pixi.js时做的第一个小游戏。是V5版本，另外加入了screenfull处理全屏。 有咨询可以联系我 这款游戏没有什么动画只是PIXI的基本概念。
华容道最短步数求解
05-24
解华容道的一种方法，效率较高，使用c++编写，易理解，只提供求最短步数，不提供输出具体移动过程
Jquery实现数字华容道小游戏
weixin_42870117的博客
01-14 2653
<!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>数字华容道</title> <script type="text/javascript" src="jquery.min.js"></script> <style type="...
华容道游戏（上）
weixin_34106122的博客
04-29 343
此为《算法的乐趣》读书笔记，我用javascript（ES6）重新实现算法。 华容道游戏看似简单，但求解需要设计的数据结构比较复杂，还牵涉到棋类游戏的棋局判断，所以整个过程还是挺费劲的。我尽量用面向对象的思想来进行封装，整个过程将分成几个部分记录下来，今天是第一部分，数据结构的定义与初始化。 华容道游戏介绍 华容道游戏据说来源于三国故事“...
华容道算法之性能优化
Herok
04-11 2694
上篇文章讲解了华容道算法基本算法知识，也是最简单的，效率也是最低的。这篇文章讲解高效率算法。从下篇文章开始主要分析linux 驱动代码以及嵌入式相关设计知识。本次编码采用棋子在棋盘中的位置编码，顺序是从左往右/从上到下。以横刀立马举例说明。正方形的应该是1（记得从0开始计算），横方块值是0x80 、竖方块是0x909、单个方格值是0x96000、空格是0x60000 编程思路与上一篇文章一致，...
【面试现场】如何编程解决华容道问题？
yeluoxiang的专栏
09-17 828
小史是一个应届生，虽然学的是电子专业，但是自己业余时间看了很多互联网与编程方面的书，一心想进BAT互联网公司。今天他就去一家外企面试了。【面试前】面试前，小史就收到了中英...
web小游戏开发：华容道（完）
文盲的专栏
05-01 878
因为我们对每个角色都有一个专有样式，我们可以对 click 事件进行监听，并获取 click 所点击的对象，来判定角色以及其所在位置，并计算是否可以移动，可以移动几个方向之类的。然后，由于每个角色，可能会有多个移动方向，所以，先判定可以移动的方向，然后由用户选择方向移动。记录步数之类的功能，可以自行完善了，胜利判定，可以在移动后，判定曹操是否到达了3,1的位置，如果达到了，就是胜利。之后，直到游戏完成之前，html 内容就不再修改了，之后的其他游戏，正常内容，也都会是这样，不再变动。目前 js 内容如下。
bfs算法可用来求解华容道的最小解吗
最新发布
01-12
BFS算法（广度优先搜索算法）可以用来求解华容道的最小解。华容道是一种经典的益智游戏，目标是将一组方块按照规定的顺序和方向移动，最终将特定的方块移动到指定位置，形成特定的图案或排列。 BFS算法是一种在图或树结构上进行搜索的算法，它从起始顶点开始，逐层遍历相邻的顶点，直到找到目标顶点为止。在华容道中，我们可以将每个游戏状态（即方块的排列）看作图中的一个顶点，而每次移动操作可以看作是从一个顶点到另一个相邻的顶点的一条边。 使用BFS算法，我们可以从初始状态开始，逐步搜索所有可能的移动路径，直到找到最优解为止。由于BFS算法的特性，它能够保证找到的解一定是最短的，因此可以用来求解华容道的最小解。 总之，BFS算法可以有效地应用于求解华容道的最小解，通过逐层搜索所有可能的移动路径，最终找到最优解。通过合理的建模和算法设计，我们可以利用BFS算法来帮助解决华容道这类益智游戏，为玩家提供更好的游戏体验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值