java迷宫回溯找最短路径问题(多策略)

最新推荐文章于 2025-03-25 20:45:16 发布
最新推荐文章于 2025-03-25 20:45:16 发布
阅读量1.6k 收藏 20
点赞数 3
分类专栏： 数据结构 算法 文章标签： 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wodebokecsdn/article/details/129143174
版权

1、首先我们先明确迷宫，并创建

如上图，1为墙，中间的1为挡板墙，

由图我们可以看出这是一个二维数组

/**
     * 创建地图
     * @return
     */
    public static int [][] createMap(){
        int [][] mapNew = new int[8][7];
        //1表示墙，不能走
        for (int i=0;i<7;i++){
            mapNew[0][i] = 1;
            mapNew[7][i] = 1;
        }
        //1表示墙，不能走
        for (int i=0;i<8;i++){
            mapNew[i][0] = 1;
            mapNew[i][6] = 1;
        }
        //设置墙体
        setWall(mapNew,1,4);
        setWall(mapNew,2,4);
        setWall(mapNew,3,1);
        setWall(mapNew,3,2);
        setWall(mapNew,5,3);
        setWall(mapNew,5,4);
        setWall(mapNew,6,4);
        return mapNew;
    }
    /**
     *设置挡板
     */
    public static void setWall(int [][] mapNew, int i, int j){
        mapNew[i][j] = 1;
    }
    /**
     * 展示地图
     * @param map
     */
    public static void showMap(int [][] map){
        for (int i = 0; i < map.length; i++) {
            int [] item = map[i];
            for (int j = 0; j < item.length; j++) {
                System.out.print(item[j]+" ");
            }
            System.out.println();
        }
    }

2、开始寻找路线

思路：

1：设定map[1][1]为起始位置，map[6][5]为出口位置

2：0表示还未走过可以走，如果走过则标记为2

3：定义小球的行走策略，小球按着上-右-下-左的顺序走（走的策略可以自己定义，策略会决定路 线）

4：小球走过的路线不允许走

5：如果是死路，则标记为3

开始编码：

 /**
     * 寻找路线
     * @param i
     * @param j
     * @return
     */
    public static boolean getWay(int i, int j){

        //如果出口为2，则说明找到了出口
        if(map[6][5] == 2){
            return true;
        }else{
            //如果是0则可以走，并标记为2
            if(map[i][j] == 0){
                map[i][j] = 2;
                //接下来小球就按定义的策略执行
                //按四个方向开始探测（上-右-下-左）
                if(getWay(i-1,j)){//如果上行可以走
                    return true;
                }else if(getWay(i,j+1)){ //右
                    return true;
                }else if(getWay(i+1,j)){ //下
                    return true;
                }else if(getWay(i,j-1)){//左
                    return true;
                }else{
                    //这种情况就是小球上下左右都行不通了
                    map[i][j] = 3;
                    return false;
                }
            }
            return false;
        }
    }

注意，这里有个递归回溯，大家可以了解一下递归的运行机制，涉及到栈的知识点。

回溯到上一步后，继续尝试向右运行，推到栈中，发现是0不是墙，则继续先向上探索，发现是墙，在回溯，一直重复此过程，知道找到map[6][5] == 0并标记为2，则退出递归，从而找到出口

完整代码

public class 迷宫回溯单测略 {

    public static int [][] map;

    public static void main(String[] args) {
        //创建地图
        map = createMap();

        //寻找路线
        getWay(1,1);
        showMap(map);
    }

    /**
     * 创建地图
     * @return
     */
    public static int [][] createMap(){
        int [][] mapNew = new int[8][7];
        //1表示墙，不能走
        for (int i=0;i<7;i++){
            mapNew[0][i] = 1;
            mapNew[7][i] = 1;
        }
        //1表示墙，不能走
        for (int i=0;i<8;i++){
            mapNew[i][0] = 1;
            mapNew[i][6] = 1;
        }
        //设置墙体
        setWall(mapNew,1,4);
        setWall(mapNew,2,4);
        setWall(mapNew,3,1);
        setWall(mapNew,3,2);
        setWall(mapNew,5,3);
        setWall(mapNew,5,4);
        setWall(mapNew,6,4);
        return mapNew;
    }

    public static void setWall(int [][] mapNew, int i, int j){
        mapNew[i][j] = 1;
    }
    /**
     * 展示地图
     * @param map
     */
    public static void showMap(int [][] map){
        for (int i = 0; i < map.length; i++) {
            int [] item = map[i];
            for (int j = 0; j < item.length; j++) {
                System.out.print(item[j]+" ");
            }
            System.out.println();
        }
    }

    /**
     * 寻找路线
     * @param i
     * @param j
     * @return
     */
    public static boolean getWay(int i, int j){

        //如果出口为2，则说明找到了出口
        if(map[6][5] == 2){
            return true;
        }else{
            //如果是0则可以走，并标记为2
            if(map[i][j] == 0){
                map[i][j] = 2;
                //接下来小球就按定义的策略执行
                //按四个方向开始探测（上-右-下-左）
                if(getWay(i-1,j)){//如果上行可以走
                    return true;
                }else if(getWay(i,j+1)){ //右
                    return true;
                }else if(getWay(i+1,j)){ //下
                    return true;
                }else if(getWay(i,j-1)){//左
                    return true;
                }else{
                    //这种情况就是小球上下左右都行不通了
                    map[i][j] = 3;
                    return false;
                }
            }
            return false;
        }
    }


}

多策略模式

上面我们是规定死了小球走的策略即上-右-下-左，并且，从步数来看，这肯定不是小球找到出路的最佳步数，从图中我们看到小球甚至走了两个死步，就是3

经过我们分析，小球先向下走，在向右走，走的步数是最少的，但这只是我们的猜测，接下来验证我们的猜测对不对。

  1. 生成策略

上下左右四个方向，排列组合，用递归方式生成策略

A44 = 4*3*2*1 = 24种

最后统一上代码，这里只展示这个方法

direction和clArr均为静态属性，后续有全部代码

/**
     * 获取所有策略
     */
    public static void getAllCl(String[] resultList, int resultIndex){
        direction[0] = "top";
        direction[1] = "right";
        direction[2] = "bottom";
        direction[3] = "left";
        int length = resultList.length;
        if(resultIndex>= length){
//            System.out.println("处理完成");
            //深拷贝resultList到策略数组中
            clArr.add( Arrays.copyOf(resultList,resultList.length));
            return;
        }
        for (int i=0;i<direction.length;i++){
            boolean exists = false;
            for (int j=0;j<resultIndex;j++){
                if (direction[i].equals(resultList[j])) {
                    exists = true;
                    break;
                }
            }
            if (!exists) { // 排列结果不存在该项，才可选择
                resultList[resultIndex] = direction[i];
                getAllCl(resultList, resultIndex + 1);
            }
        }

    }

这里展示递归思路图，因为4个元素的递归深度很深，所以我用三个元素来演示

  1. 有了策略之后，我们生成地图

注意：这里可以用一张地图，也可以每个策略对应一张，我建议选后者，因为思路清晰，能看到每个策略走完的轨迹

我们通过一个对象来记录策略和步数和地图

我们生成完策略之后，遍历来创建一个一个的对象

 public static void main(String[] args) {
        //创建地图
//        int [][] map = new int[8][7];

        //生成策略
        getAllCl(new String[4],0);

//        [left, bottom, right, top]

        String []clMock = new String[4];
        clMock[0] = "top";
        clMock[1] = "right";
        clMock[2] = "bottom";
        clMock[3] = "left";

        for (int i=0;i<clArr.size();i++){
            //开始寻找路线
            String [] clItem = clArr.get(i);
            //创建地图
            int [][] newMap = createMap();
            showMap(newMap);
            System.out.println(" ");
            //创建对象
            MapObj mapObj = new MapObj(newMap,0,clItem);
        }
    }

创建完之后，开始针对不同的策略来找路径

思路跟单策略找是一样的

/**
     * 思路：
     * 1：设定map[6][5]为出口
     * 2：0表示还未走过，如果小球走过则标记为2
     * 3：小球按着上-右-下-左的顺序走（走的策略自己定义，策略会决定路线）
     * 4：如果小球走过的路径则不允许走
     * 5：如果是死路则标记为3
     * @param i 点i坐标
     * @param j 点的j坐标
     * @return
     */
    public static boolean setWay(MapObj mapObj, int i,int j){
        String [] cl = mapObj.getCl();
        int [][] map = mapObj.getMap();
//        map[6][5]为出口，找到出口退出递归
        mapObj.setStep(mapObj.getStep()+1);
        if(map[6][5] == 2){
            resultList.add(mapObj);
            return true;
        }else{
            //如果当前位置可以走则返回true，并将该位置标记为已走过
            if(map[i][j] == 0){
                map[i][j] = 2;

                boolean flag = false;
                //策略不固定所以循环来判断往哪个方向走
                for (int k = 0; k < cl.length; k++) {
                    String item = cl[k];
                    if(item.equals("top") && setWay(mapObj,i-1,j)){//上行
                        return true;
                    }else if(item.equals("right") && setWay(mapObj,i,j+1)){ //右行
                        return true;
                    }else if(item.equals("bottom") && setWay(mapObj,i+1,j)){ //下行
                        return true;
                    }else if(item.equals("left") && setWay(mapObj,i,j-1)){ //左行
                        return true;
                    }
                }
                //如果四个方向都走不通则是死路，标记为3
                map[i][j] = 3;
                flag = false;
                return flag;
                //但策略思路
//                if(setWay(mapObj,i-1,j)){//上行
//                    return true;
//                }else if(setWay(mapObj,i,j+1)){ //右行
//                    return true;
//                }else if(setWay(mapObj,i+1,j)){ //下行
//                    return true;
//                }else if(setWay(mapObj,i,j-1)){ //左行
//                    return true;
//                }else{
//                    map[i][j] = 3;
//                    return false;
//                }
            }else{
                return false;
            }
        }
    }

OK 这样我们就算是完成了

最后的结果为

接下来贴上多策略完整代码，如果大家想看所有的结果，resultList这个就是，遍历打印即可

import java.util.*;

public class 迷宫回溯 {

    public static String [] direction = new String[4];

    public static List<String []> clArr = new ArrayList();

    //用来储存结果
    public static List<MapObj> resultList = new ArrayList();

    //用来记录步数
    public static int step;

    public static void main(String[] args) {
        //创建地图
//        int [][] map = new int[8][7];

        //生成策略
        getAllCl(new String[4],0);

//        [left, bottom, right, top]

        String []clMock = new String[4];
        clMock[0] = "top";
        clMock[1] = "right";
        clMock[2] = "bottom";
        clMock[3] = "left";

        for (int i=0;i<clArr.size();i++){
            //开始寻找路线
            String [] clItem = clArr.get(i);
            //创建地图
            int [][] newMap = createMap();
            showMap(newMap);
            System.out.println(" ");
            //创建对象
            MapObj mapObj = new MapObj(newMap,0,clItem);
            setWay(mapObj,1,1);
        }
        System.out.println("查询完路线以后");
        //将结果排序
//        resultList.sort(new Comparator<MapObj>() {
//            @Override
//            public int compare(MapObj a, MapObj b) {
//                return a.getStep()-b.getStep();
//            }
//        });
        //将结果排序优化
//        resultList.sort((MapObj a,MapObj b)-> a.getStep()-b.getStep());
        //将结果排序再优化
        resultList.sort(Comparator.comparingInt(MapObj::getStep));

        System.out.printf("最短的步数为：%d \n",resultList.get(0).getStep());
        System.out.printf("最短的策略为：%s \n",Arrays.toString(resultList.get(0).getCl()));
        System.out.println("地图路线为：");
        showMap(resultList.get(0).getMap());


    }

    /**
     * 创建地图
     * @return
     */
    public static int [][] createMap(){
        int [][] mapNew = new int[8][7];
        //1表示墙，不能走
        for (int i=0;i<7;i++){
            mapNew[0][i] = 1;
            mapNew[7][i] = 1;
        }
        //1表示墙，不能走
        for (int i=0;i<8;i++){
            mapNew[i][0] = 1;
            mapNew[i][6] = 1;
        }
        //设置墙体
        setWall(mapNew,1,4);
        setWall(mapNew,2,4);
        setWall(mapNew,3,1);
        setWall(mapNew,3,2);
        setWall(mapNew,5,3);
        setWall(mapNew,5,4);
        setWall(mapNew,6,4);
        return mapNew;
    }

    /**
     * 设置挡板
     * @param mapNew
     * @param i
     * @param j
     */
    public static void setWall(int [][] mapNew, int i, int j){
        mapNew[i][j] = 1;
    }

    /**
     * 思路：
     * 1：设定map[6][5]为出口
     * 2：0表示还未走过，如果小球走过则标记为2
     * 3：小球按着上-右-下-左的顺序走（走的策略自己定义，策略会决定路线）
     * 4：如果小球走过的路径则不允许走
     * 5：如果是死路则标记为3
     * @param i 点i坐标
     * @param j 点的j坐标
     * @return
     */
    public static boolean setWay(MapObj mapObj, int i,int j){
        String [] cl = mapObj.getCl();
        int [][] map = mapObj.getMap();
//        map[6][5]为出口，找到出口退出递归
        mapObj.setStep(mapObj.getStep()+1);
        if(map[6][5] == 2){
            resultList.add(mapObj);
            return true;
        }else{
            //如果当前位置可以走则返回true，并将该位置标记为已走过
            if(map[i][j] == 0){
                map[i][j] = 2;

                boolean flag = false;
                //策略不固定所以循环来判断往哪个方向走
                for (int k = 0; k < cl.length; k++) {
                    String item = cl[k];
                    if(item.equals("top") && setWay(mapObj,i-1,j)){//上行
                        return true;
                    }else if(item.equals("right") && setWay(mapObj,i,j+1)){ //右行
                        return true;
                    }else if(item.equals("bottom") && setWay(mapObj,i+1,j)){ //下行
                        return true;
                    }else if(item.equals("left") && setWay(mapObj,i,j-1)){ //左行
                        return true;
                    }
                }
                //如果四个方向都走不通则是死路，标记为3
                map[i][j] = 3;
                flag = false;
                return flag;
                //但策略思路
//                if(setWay(mapObj,i-1,j)){//上行
//                    return true;
//                }else if(setWay(mapObj,i,j+1)){ //右行
//                    return true;
//                }else if(setWay(mapObj,i+1,j)){ //下行
//                    return true;
//                }else if(setWay(mapObj,i,j-1)){ //左行
//                    return true;
//                }else{
//                    map[i][j] = 3;
//                    return false;
//                }
            }else{
                return false;
            }
        }
    }

    /**
     * 获取所有策略
     */
    public static void getAllCl(String[] resultList, int resultIndex){
        direction[0] = "top";
        direction[1] = "right";
        direction[2] = "bottom";
        direction[3] = "left";
        int length = resultList.length;
        if(resultIndex>= length){
//            System.out.println("处理完成");
            //深拷贝resultList到策略数组中
            clArr.add( Arrays.copyOf(resultList,resultList.length));
            return;
        }
        for (int i=0;i<direction.length;i++){
            boolean exists = false;
            for (int j=0;j<resultIndex;j++){
                if (direction[i].equals(resultList[j])) {
                    exists = true;
                    break;
                }
            }
            if (!exists) { // 排列结果不存在该项，才可选择
                resultList[resultIndex] = direction[i];
                getAllCl(resultList, resultIndex + 1);
            }
        }

    }

    /**
     * 展示地图
     * @param map
     */
    public static void showMap(int [][] map){
        for (int i = 0; i < map.length; i++) {
            int [] item = map[i];
            for (int j = 0; j < item.length; j++) {
                System.out.print(item[j]+" ");
            }
            System.out.println();
        }
    }
}

class MapObj{
    private int [][] map;
    private int step;
    private String [] cl;

    public MapObj(int[][] map, int step, String[] cl) {
        this.map = map;
        this.step = step;
        this.cl = cl;
    }


    public int[][] getMap() {
        return map;
    }

    public void setMap(int[][] map) {
        this.map = map;
    }

    public int getStep() {
        return step;
    }

    public void setStep(int step) {
        this.step = step;
    }

    public String[] getCl() {
        return cl;
    }

    public void setCl(String[] cl) {
        this.cl = cl;
    }
}

迷宫最短路径 java_Java迷宫代码，广度优先遍历，最短路径
weixin_36180385的博客
02-12 373
/*** 描述: 定义迷宫节点类型*/private static classMazeNode {//节点的值intval;//节点的x和y坐标intx;inty;//节点四个方向的行走状态，true表示可以走，false表示不能走boolean[] state;/*** 迷宫路径初始化*@paramdata*@parami*@paramj*/public MazeNode(int data, i...
DFS(深度优先搜索) 求迷宫最短路径 C / java代码实现分析
m0_59884552的博客
06-21 1916
关于啊哈算法dfs迷宫最短路径的代码实现（C/JAVA）
java实现的求迷宫最短路径算法
04-14
用java实现的求迷宫最短路径的算法源代码，代码中有大量注释，容易看懂
迷宫问题——（java）(bfs)
最新发布
2301_76231651的博客
03-25 803
我们每次只添加队头的相邻元素，然后添加完队头的相邻元素（注意：只添加没有访问过的元素，1虽然也是相邻元素，但是1已经被访问过了，所以添加1到队列），队头就算已经访问过了。队首的元素不断变化，队尾的元素不断添加，最后直到每一个节点都被访问过，那么此队列中就无法添加元素了，队列中的元素就会不断的减少直到变成空队列。每次将队首的元素的取出，然后添加和队首元素相邻并且没有被访问过的元素到队尾，然后更新队列中的每一个元素到起点的最短距离。判断队首元素是否被访问过，如果被访问过，就判断队首元素的下一个元素。
迷宫问题（Java实现，求最短路径）
就这样吧
07-10 8893
题目链接 迷宫问题 定义一个二维数组： int maze[n][m]; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 输入描述： 一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。 int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 样式输出： (0,0) (
迷宫最短路径【Java实现】
Infinity_and_beyond的博客
02-10 1794
现有一个n∗m大小的迷宫，其中1表示不可通过的墙壁，0表示平地。每次移动只能向上下左右移动一格，且只能移动到平地上。假设左上角坐标是(1,1)，行数增加的方向为x增长的方向，列数增加的方向为y增长的方向，求从迷宫左上角到右下角的最少步数的路径。
JAVA：迷宫最短路径问题
qq_63567731的博客
05-24 1272
JAVA：迷宫最短路径问题
c语言支持自己创建迷宫，并求解最短路径.zip
09-09
在C语言中创建一个迷宫并寻找最短路径是一个经典的计算机科学问题，涉及到算法设计、数据结构以及递归等编程技巧。在这个项目中，我们可能会遇到以下知识点： 1. **迷宫表示法**：通常，迷宫可以用二维数组或者矩阵...
数据结构------递归+迷宫问题+最短路径问题解决思路
萌新Java工程师
12-20 2065
递归 场景以及概念 迷宫回溯问题 简单的说:递归就是方法自己调用自己，每次调用时传入不同的变量.递归有助于编程者解决复杂的问题，同时可以让代码变得简洁。 调用机制 1.打印问题 package com.wang.Recursion; /** * @author 王庆华 * @version 1.0 * @date 2020/12/20 9:30 * @Description TODO * @pojectname 递归代码 */ public class RecursionTest {
java迷宫问题最短路径
10-13
对于Java迷宫问题，可以使用广度优先搜索（BFS）或者Dijkstra算法来求解最短路径。其中BFS适用于无权图，而Dijkstra算法适用于有权图。 具体实现可以先将迷宫转化为图，然后从起点开始进行搜索，直到找到终点为止。...
JAVA|迷宫问题输出最短路径
qq_42752651的博客
12-16 2941
0.背景 本学期Java课程设计选题为迷宫游戏。 课设的迷宫主要思路为：设置不同关卡，每个关卡的迷宫样式固定，每次游戏随机生成起点和终点。 核心问题即为： 1、随机生成的两点之间是否有路径可走？ 2、最短路径是否小于等于游戏给出的步数限制？ 3、点击最短生成路径按钮显示最短路径。 游戏的整体框架戳此处链接https://blog.youkuaiyun.com/qq_42391904/article/detai...
回溯法求矩阵左上到右下的最短路径
01-03
给定一个N x N 的数字矩阵， 每个点都有一个正整数（大小为0-9），从左上角出发， 每次只能向右或者向下移动一个单位，直到走到右下角为止。求得一条路线，使得这条路线上的数字和最小。 输入： 第一行输入 N 表示数字矩阵为N行N列 第二行到第 N+1行，每行N个数字 表示N x N矩阵 输出： 第一行输出该路线上的数字和 第二行输出这条路线上的各个数字的行号和列号（如果有多条路径，输出任意一条）
java迷宫寻找最短路径
mischen520的博客
11-24 1280
利用广度优先遍历算法的特点，由于迷宫每次只能走一格，所以对于任意一个节点，bfs第一次到达该点时一定是最短路径。
用Java实现迷宫最短路径算法
热门推荐
c_yejiajun的博客
01-26 1万+
宽度优先搜索 迷宫最短路径用宽度优先搜索（bfs）相比用深度优先搜索（dfs）的好处在于bfs每次计算都是最短路径不存在重复计算，而dfs每计算出一条可行的路径都要与先前的路径比较，然后储存最短路径。 而bfs的思想是先计算出围绕起点的所有点的距离并储存起来 S是起点，数字为该点到S的距离 根据该思想为下题写一段程序 在N*M的迷宫中，计算出S到G的最短路径 ‘#’，’.’， ‘S’， 'G’...
【java】走迷宫最短路径
wow_bc的博客
04-22 7466
输入一个n*m的迷宫，1表示空地，0表示障碍物，输出从某个点到某个点的最短路径 样例输入： 6 5 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0 0 0 3 样例输出： DDDDRRUUURU import java.util.LinkedList; import java.util.Que
迷宫最短路径 java_java – 在迷宫中寻找最短路径
weixin_30189559的博客
02-12 326
我是业余程序员,学习如何编程.我从来没有上过任何计算机科学课程,所以我很难解决这个琐碎的问题：class Room {String name;ArrayList neighbors = new ArrayList();// constructor with name// gettersvoid addNeighbor(Room room) {neighbors.add(room);}}class ...
迷宫的最短路径 BFS JAVA
Hiraccc_的博客
02-09 1241
用队列实现BFS: java.util.Queue 初始化一个无穷大的数INF，准备一个距离二维数组，数组规模与输入相匹配，每一元素初始化为INF。这个距离二维数组可以记录从起点到当前位置的距离，也可以作为记忆化使用(即当前位置存储的距离 != INF)。 迷宫地图： /* 10 #S######.# ......#..# .#.##.##.# .#........ ##.##.#### ....#....# .#######.# ....#..... .####.###. ....#...G# */
java 迷宫最短路径_用Java实现迷宫最短路径算法
weixin_39931146的博客
02-15 2035
单源最短路(Bellman - Ford算法)宽度优先搜索迷宫最短路径用宽度优先搜索(bfs)相比用深度优先搜索(dfs)的好处在于bfs每次计算都是最短路径不存在重复计算，而dfs每计算出一条可行的路径都要与先前的路径比较，然后储存最短路径。而bfs的思想是先计算出围绕起点的所有点的距离并储存起来S是起点，数字为该点到S的距离根据该思想为下题写一段程序在N*M的迷宫中，计算出S到G的最短路径‘#...
java 迷宫寻路_PTA-迷宫寻路（输出最短路径）
weixin_39712865的博客
02-27 823
给定一个M行N列的迷宫图，其中 "0"表示可通路，"1"表示障碍物，无法通行。在迷宫中只允许在水平或上下四个方向的通路上行走，走过的位置不能重复走。5行8列的迷宫如下：0 1 1 1 0 0 0 00 0 0 1 0 0 0 00 1 0 0 0 1 0 00 1 1 1 0 1 1 01 0 0 0 0 0 0 0则从左上角(1，1)至右下角(5，8)的最短路径为：1,1--》2,1--》2,2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

攻城狮狮

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值