【蓝桥杯Java组】用Java带你暴走迷宫—DFS深度优先搜索

已于 2022-04-08 16:49:13 修改
阅读量2.8k 收藏 99
点赞数 57
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 java 深度优先 算法
于 2022-03-25 17:45:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51338272/article/details/123737656
版权

header

☕前言：

📖📖走迷宫一类的问题一般都是暴力搜索解决，搜索的方法有两种：深度优先（DFS）和广度优先（BFS），而提到DFS就离不开递归，涉及到递归的问题理解起来还是有难度的，代码编写不当很容易造成栈溢出。

🌻🌻今天就用三道走迷宫问题带你彻底搞懂怎么用DFS秒杀迷宫类问题~

题目传送门：🚀🚀🚀

三道练习题目全部来源于计蒜客平台。

题目链接
迷宫（一）https://nanti.jisuanke.com/t/T1595
迷宫（二）http://nanti.jisuanke.com/t/T1596
迷宫（三）https://nanti.jisuanke.com/t/T1597

🍋走迷宫—DFS深搜：

😎不废话，直接上题，题来~

插图

🍔迷宫（一）：

题目

一天蒜头君掉进了一个迷宫里面，蒜头君想逃出去，可怜的蒜头君连迷宫是否有能逃出去的路都不知道。

看在蒜头君这么可怜的份上，就请聪明的你告诉蒜头君是否有可以逃出去的路。

输入格式

第一行输入两个整数 n 和 m，表示这是一个 n×m 的迷宫。

接下来的输入一个 n 行 m 列的迷宫。其中 'S' 表示蒜头君的位置，'*'表示墙，蒜头君无法通过，'.'表示路，蒜头君可以通过'.'移动，'T'表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。

输出格式

输出一个字符串，如果蒜头君可以逃出迷宫输出"yes"，否则输出"no"。

数据范围

1<=n，m<=10。

输出时每行末尾的多余空格，不影响答案正确性

样例输入1

3 4
S**.
..*.
***T

样例输出1

no

样例输入2

3 4
S**.
....
***T

样例输出2

yes

👩🏻‍🏫题目让我们判断给定的迷宫是否有可行解，也就是能否从S走到T，但是不要着急，让我们先来处理一下输入：

⭐先设置两个全局变量n，m用来接收迷宫的行数与列数，同时定义一个全局的二维char数组用来存储迷宫。

public static int n;
public static int m;
public static char[][] maze;

⭐在Java中是不能读入单个字符的，我们可以直接读取一行字符串，再转化为数组，不用担心，字符串转数组在Java中已经封装好了。

⭐注意S的位置题目中并没有说是在左上角，所以在输入的时候还要存储下S的位置。

Scanner sc = new Scanner(System.in);
n = sc.nextInt();
m = sc.nextInt();
maze = new char[n][m];
int x = 0, y = 0;
for (int i = 0; i < n; i++) {
	String str = sc.next();
	int start = str.indexOf('S');
 	if (start != -1) {
		x = i;
		y = start;
	}
	maze[i] = str.toCharArray();
}
sc.close();

⭐输入处理好了，现在来思考一下怎么用DFS走迷宫。

⭐在走迷宫时肯定不能走到迷宫外面，不妨写一个方法用来判断现在的位置是否还在迷宫内。

public static boolean inMaze(int x, int y) {
	return (0 <= x && x < n && 0 <= y && y < m);
}

⭐仅仅判断是否在迷宫内还不够，我们在走迷宫时还要防止来回兜圈子，所以还需要一个二维数组用来标记走过的位置，走过某个位置以后就不再走了。

public static boolean[][] vis;

同时在主方法中对数组进行实例化：vis = new boolean[n][m]

⭐有了以上的准备工作，现在我们可以来正式编写DFS的代码了，首先定义一个方法，用来表示搜索到了某个位置，返回值是Boolean类型，用来返回迷宫是否有可行解（当然也可以返回void，用全局变量来表示迷宫是否可行）：

public static boolean dfs(int x, int y)

由于后面要用到递归，这里也很容易想到递归出口，走到T就不走了：

if (maze[x][y] == 'T') {
	return true;
}

然后我们可以将当前位置进行标记，并依次尝试上左下右（习惯用逆时针）四个方向是否可以走，递归调用dfs()。

public static boolean dfs(int x, int y) {
	//	递归出口
	if (maze[x][y] == 'T') {
		return true;
	}
	//	标记已经走过
	vis[x][y] = true;
	int tx = x - 1, ty = y;
	if (inMaze(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*') {
	//	可以向这个方向走，并且能走出去，返回true
		if (dfs(tx, ty))
		return true;
	}
	tx = x;
	ty = y - 1;
	if (inMaze(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*') {
		if (dfs(tx, ty))
			return true;
	}
	tx = x + 1;
	ty = y;
	if (inMaze(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*') {
		if (dfs(tx, ty))
			return true;
	}
	tx = x;
	ty = y + 1;
	if (inMaze(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*') {
		if (dfs(tx, ty))
			return true;
	}
	return false;
}

⭐如果你觉得尝试四个方向的代码太长了，还可以简化一下，使用一个数组来表示要走的方向。

public static int[][] dir = new int[][]{
	{-1, 0}, {0, -1}, {1, 0}, {0, 1}
};

使用循环来向四个方向尝试：😉

for (int i = 0; i < 4; i++) {
	int tx = x + dir[i][0];
	int ty = y + dir[i][1];
	if (inMaze(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*') {
		if (dfs(tx, ty)) {
			return true;
		}
	}
}

⭐将上面的代码组织起来，这道题目就解决了。

🍦AC代码（Java）：
import java.util.Scanner;

public class Main {

    public static int n;
    public static int m;
    public static char[][] maze;
    public static boolean[][] vis;
    public static int[][] dir = new int[][]{
        {-1, 0}, {0, -1}, {1, 0}, {0, 1}
    };

    public static boolean inMaze(int x, int y) {
        return (0 <= x && x < n && 0 <= y && y < m);
    }

    public static boolean dfs(int x, int y) {
        if (maze[x][y] == 'T') {
            return true;
        }
        vis[x][y] = true;
        for (int i = 0; i < 4; i++) {
            int tx = x + dir[i][0];
            int ty = y + dir[i][1];
            if (inMaze(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*') {
                if (dfs(tx, ty)) {
                    return true;
                }
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        maze = new char[n][m];
        vis = new boolean[n][m];
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            String str = sc.next();
            int start = str.indexOf('S');
            if (start != -1) {
                x = i;
                y = start;
            }
            maze[i] = str.toCharArray();
        }
        sc.close();
        String ans = dfs(x, y) ? "yes" : "no";
        System.out.println(ans);
    }
}

结果

插图

🌭迷宫（二）：

题目

蒜头君在你的帮助下终于逃出了迷宫，但是蒜头君并没有沉浸于喜悦之中，而是很快的又陷入了思考，从这个迷宫逃出的最少步数是多少呢？

输入格式

第一行输入两个整数 n 和 m，表示这是一个 n×m 的迷宫。

接下来的输入一个 n 行 m 列的迷宫。其中 'S' 表示蒜头君的位置，'*'表示墙，蒜头君无法通过，'.'表示路，蒜头君可以通过'.'移动，'T'表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。

输出格式

输出整数，表示蒜头君逃出迷宫的最少步数，如果蒜头君无法逃出迷宫输出 -1−1。

数据范围

1<=n，m<=10

输出时每行末尾的多余空格，不影响答案正确性

样例输入1

3 4
S**.
..*.
***T

样例输出1

-1

样例输入2

3 4
S**.
....
***T

样例输出2

5

👩🏻‍🏫这道题和上一道题的区别在于它让我们得到迷宫可行解的最少步数，因此我们可以在上一到题的基础上，加入全局变量step用来计数，同时加入minStep全局变量保存最少的步数。

本题我们尝试让函数返回void，并用全局变量flag标记迷宫能否走通。

public static int step = 0;
public static int minStep = Integer.MAX_VALUE;

⭐每走一步，step加一，当走到T时就更新我们的最小路径：

if (maze[x][y] == 'T') {
	minStep = Math.min(minStep, step);
	flag = true;
	return;
}

⭐迷宫的可行解不只有一个，上一题中的dfs()在找到一种方案后就直接返回true了，不会尝试其他走法，因此为了搜索所有方案，我们需要用到深度优先搜索中一个很重要的技巧：回溯。

👉🏻回溯简单理解就是在我们每次做出动作后，都要在递归调用的后面撤销刚刚的动作。

比如我们标记了vis[x][y] = true，并让step++，在递归调用后还要将其撤销，这样dfs()函数就会搜索所有可行的方案：

public static void dfs(int x, int y) {
	if (maze[x][y] == 'T') {
		minStep = Math.min(minStep, step);
		flag = true;
		return;
	}
	vis[x][y] = true;
	step++;
	for (int i =0; i < 4; i++) {
		int tx = x + dir[i][0];
		int ty = y + dir[i][1];
		if (in(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*')
		dfs(tx, ty);
	}
	// 回溯，不然搜出一条可行路径就不会继续搜了
	vis[x][y] = false;
	step--;
}

⭐看到这里的小伙伴是不是以为这道题终于结束了，不要高兴的太早，这里的代码虽然没有问题，但是提交测试会超时，所以我们还需要对dfs()进行剪枝。

👉🏻所谓剪枝就是剪掉一些不可能的方案，减少搜索的次数。

👉🏻本题的剪枝比较简单，当我们的步数已经超过之前某个方案得到最小路径时，接着走不可能得到更小的步数，这样的话就没必要继续往下走了，直接让函数返回。

if (step > minStep)
	return;

🍻至此，本题已经搞定了。

AC代码（Java）：
import java.util.Scanner;

public class Main {

    public static int n;
    public static int m;
    public static char[][] maze;
    public static boolean[][] vis;
    public static int[][] dir = new int[][]{
        {-1, 0}, {0, -1}, {1, 0}, {0, 1}
    };
    public static boolean flag = false;
    public static int step = 0;
    public static int minStep = Integer.MAX_VALUE;

    public static boolean in(int x, int y) {
        return 0 <= x && x < n && 0 <= y && y < m;
    }

    public static void dfs(int x, int y) {
        // 剪枝，不然会超时。
        // 当前步数比之前方案的步数还大，这种情况直接排除，不可能是最佳答案。
        if (step > minStep)
            return;
        if (maze[x][y] == 'T') {
            minStep = Math.min(minStep, step);
            flag = true;
            return;
        }
        vis[x][y] = true;
        step++;
        for (int i =0; i < 4; i++) {
            int tx = x + dir[i][0];
            int ty = y + dir[i][1];
            if (in(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '*')
                dfs(tx, ty);
        }
        // 回溯，不然搜出一条可行路径就不会继续搜了
        vis[x][y] = false;
        step--;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        maze = new char[n][m];
        vis = new boolean[n][m];
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            String str = sc.next();
            int j = str.indexOf('S');
            if (j != -1) {
                x = i;
                y = j;
            }
            maze[i] = str.toCharArray();
        }
        sc.close();
        dfs(x, y);
        minStep = flag ? minStep : -1;
        System.out.println(minStep);
    }
}

提交

插图

🍟迷宫（三）：

题目

经过思考蒜头君终于解决了怎么计算一个迷宫的最短路问题，于是蒜头君找到一个新的迷宫图，来验证自己是否真的会计算一个迷宫的最短路。

为了检验自己计算的是否正确，蒜头君特邀你一起来计算。

输入格式

第一行输入两个整数 n 和 m，表示这是一个 n×m 的迷宫。

接下来的输入一个 n 行 m 列的迷宫。其中'@'表示蒜头君的位置，'#'表示墙，蒜头君无法通过，'.'表示路，蒜头君可以通过'.'移动，所有在迷宫最外围的'.'都表示迷宫的出口（蒜头君每次只能移动到四个与他相邻的位置——上，下，左，右）。

输出格式

输出整数，表示蒜头君逃出迷宫的最少步数，如果蒜头君无法逃出迷宫输出 -1−1。

数据范围

1<=n，m<=15。

输出时每行末尾的多余空格，不影响答案正确性

样例输入1

9 13
#############
#@..........#
#####.#.#.#.#
#...........#
#.#.#.#.#.#.#
#.#.......#.#
#.#.#.#.#.#.#
#...........#
#####.#######

样例输出1

11

样例输入2

4 6
#.####
#.#.##
#...@#
######

样例输出2

5

🍬这道题主要是对前面两道题目的总结，给大家练下手，学会了前面两道，这道题应该可以秒杀了~

😎不多解释，直接给出代码~

AC代码（Java）：
import java.util.Scanner;

public class Main {

    public static int n;
    public static int m;
    public static boolean flag = false;
    public static int step = 0;
    public static int minStep = Integer.MAX_VALUE;
    public static char[][] maze;
    public static boolean[][] vis;
    public static int[][] dir = new int[][]{
        {-1, 0}, {0, -1}, {1, 0}, {0, 1}
    };

    public static boolean in(int x, int y) {
        return 0 <= x && x < n && 0 <= y && y < m;
    }

    public static void dfs(int x, int y) {
        if (step > minStep)
            return;
        if (maze[x][y] == '.' && (x == 0 || x == n - 1 || y == 0 || y == m - 1)) {
            flag = true;
            minStep = Math.min(minStep, step);
            return;
        }
        vis[x][y] = true;
        step++;
        for (int i = 0; i < 4; i++) {
            int tx = x + dir[i][0];
            int ty = y + dir[i][1];
            if (in(tx, ty) && !vis[tx][ty] && maze[tx][ty] != '#') {
                dfs(tx, ty);
            }
        }
        vis[x][y] = false;
        step--;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        maze = new char[n][m];
        vis = new boolean[n][m];
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            String str = sc.next();
            int j = str.indexOf('@');
            if (j != -1) {
                x = i;
                y = j;
            }
            maze[i] = str.toCharArray();
        }
        sc.close();
        dfs(x, y);
        int ans = flag ? minStep : -1;
        System.out.println(ans);
    }
}

结果

🍌🍌🍌
看了上面三道题目不知道屏幕前的你对DFS是不是有了更进一步的理解呢？笔者感觉DFS理解起来还是有难度的，希望友友们多加练习哦~
🍍🍍🍍
创作不易，如果觉得本文对你有所帮助的话请动动小手，给博主点个免费的赞吧。🙇🏻‍♀️
🍉🍉🍉
@作者：Mymel_晗，计科专业大学牲菜狗一枚，请大佬们多多关照~

footer

蓝桥杯迷宫问题(Java实现)
weixin_63187753的博客
04-04 1342
因为最近有蓝桥杯考试，但我对于BFS还不是很熟悉。特意这里写文，记录我学习写蓝桥真题 迷宫问题的过程。 第一步将这么大又臭又长的字符串转为数组存储就吓到我了，原来只需要把字符连接起来，然后arr[i][j] = string.charAt(i*50+j) 就可以了 package forlanqiao19; import java.util.Deque; import java.util.LinkedList; import java.util.Queue; public class Main
DFS 图的深度优先遍历
12-22
通过DFS算法对图进行深度优先算法遍历，并输出遍历结果
第十届蓝桥杯比赛试题E：迷宫
ZZULI_星.夜
01-31 1519
01010101001011001001010110010110100100001000101010 00001000100000101010010000100000001001100110100101 01111011010010001000001101001011100011000000010000 010000000010101000110100001010000010...
探索迷宫算法：Processing迷宫生成与解决
最新发布
weixin_30923011的博客
09-11 967
本文还有配套的精品资源，点击获取 简介：本文将探讨如何使用Processing这一基于Java的编程语言来实现迷宫的生成和解决。主题包括随机迷宫生成技术、深度优先搜索（DFS）、广度优先搜索（BFS）、迷宫数据结构的构建、迷宫的可视化、用户交互体验以及A*寻路算法。文章还会介绍递归分治法和算法优化策略，并强调良好的编程习惯在编程学习过程中的重要性。通过分析mazes-mai...
第十届蓝桥杯E题 BFS解决
xiguanlant的博客
02-28 588
19蓝桥杯E题 迷宫 【问题描述】 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、...
深度优先搜索(DFS)(Java)
anjiao6409的博客
05-05 310
1 //1 使用邻接表 时间复杂度: O(n+e) 2 //递归 3 public void DFS(int v) 4 { 5 System.out.print(this.vexs[v].data + " "); 6 this.visited[v] = true; 7 8 for(ArcNode p = this...
迷宫 Java（dfs）
m0_51392465的博客
03-20 1163
自己构想的一道比较基础的dfs（深度搜寻）的题目： 题目：有一个n*n的迷宫，从最左上角开始，要到最右下角，只有数值为1的地方才能够移动，问能不能到达最右下面的出口，若能输出“YES”，不能就输出“NO”。 我的思路：首先我们可以构想出一个类似坐标系，从数组下标【0】【0】开始，可以向上，下，左，右四个方向移动，移动的时候如果下个位置的数值为1并且之前没走过而且在范围内（这样可以大大提高效率），那么就可以走，然后看我们有没有到终点，所以要设置一个到终点的判断语句并终止，然后输出"YES"即可，若全部走过一遍
java暴走飞鸟.zip
03-06
本篇文章将详细探讨如何使用Java来实现一个类似“飞机大战”的小游戏——“暴走飞鸟”。这个项目不仅能够帮助初学者更好地理解Java编程基础，还能让他们体验到游戏开发的乐趣。 1. **项目结构** 在“starbird-...
仿redis缓存Java版轻量级缓存组件LocalCache
09-14
仿redis缓存Java版轻量级缓存组件LocalCache，基于JVM内存实现数据缓存及过期机制
百度最新面经-Java 工程师
08-16
百度最新面经-Java 工程师 本题目涵盖了 Java 工程师所需的知识点，包括 Java 基础、数据库、网络...* 除了 Java 还用什么语言 * 大数据了解么 * 前端了解么 * 分布式了解么 * 项目的并发量是多少 * 有用什么框架么
阿里巴巴 Java 面经最新面经pdf下载
08-16
阿里巴巴 Java 面经最新面经 pdf 下载 概述：本文档是阿里巴巴 Java 面经最新面经的 pdf 下载，涵盖了 Java、数据库、分布式/中间件、微服务等多个方面的知识点。 Java 部分 1. JDK1.7 与 JDK1.8 在 G1 垃圾回收...
Java蓝桥杯——迷宫
m0_50388933的博客
04-07 982
问题描述： 迷宫地图如下： ------------ UDDLUULRUL UURLLLRRRU RRUURLDLRD RUDDDDUUUU URUDLLRRUU DURLRLDLRL ULLURLLRDU RDLULLRDDD UUDDUDUDLL ULRDLUURRR ------------ 请你计算一下，最后，有多少玩家会走出迷宫? 而不是在里边兜圈子。 解题思路： 具体代码： package easy; import java.util.Scanner; public c.
迷宫 蓝桥杯JAVA
niu341506的博客
01-23 707
题目描述 本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 下图给出了一个迷宫的平面图，其中标记为 11 的为障碍，标记为 00 的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 1010 步。其中 D、U、L、RD、U、L、R 分别表示向下、向上、向左、向右走。 对于下面
蓝桥杯 Day11 java组 DFS
qq_46274219的博客
02-10 765
所谓暴力法，是把所有可能的情况都罗列出来，然后逐一检查，从中找到答案。 暴力法往往是“低效”的代名词。不过相对其他“高效”算法，暴力法不仅简单且编码量一般都更短更好写。所以当拿到一个题目后，首先想想如何用暴力法解决。如果暴力法的代码能满足题目要求的时间和空间限制，就用暴力法。若暴力法不能满足要求，也可以把它当成对照，用来验证高级算法的正确性。 暴力搜索的思路很简单，但是有的时候操作起来并不容易。比如蓝桥杯中常见的迷宫问题： 如何用数据结构表示一个迷宫？...
蓝桥杯—迷宫
聪明绝顶的你与即将秃头的我
04-08 1055
问题描述： 下图给出了一个迷宫的平面图，其中标记为1的为障碍，标记为0的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，可以按DRRURRDDDR的顺序通过迷宫，一共10步，其中D、U、L、R表示向下，向上，向左，向右。对于下面这个更复杂的迷宫（30行50列），请找出一种通过迷宫的方式，其使用的步数最小，在步数最小的前提下，...
【dfs】java实现迷宫问题（深度优先搜索）
qq_49438920的博客
02-23 916
【dfs】java实现迷宫问题（深度优先搜索） 黑色代表障碍物 白色代表空地 要求输入： m行n列 地图 起始坐标 终点坐标 输出： 最短路径长度 例如： 输入： 5 4 1 1 2 1 1 1 1 1 1 1 2 1 1 2 1 1 1 1 1 2 1 1 4 3 输出： 7 在这里插入代码片 ...
java 实现蓝桥杯模拟空地长草 DFS
一个很懒的人
07-06 465
空地长草 求解方法 dfs。 题目：   小明有一块空地，他将这块空地划分为 n 行 m 列的小块，每行和每列的长度都为 1。 　　小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。 　　这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，这四小块空地都将变为有草的小块。 　　请告诉小明，k 个月后空地上哪些地方有草。 　　 输入：   输入的第一行包含两个整数 n, m。接下来 n 行，每行包含 m 个字母，表示初始的空地状态，字母之间没
蓝桥杯大学B组JAVA 迷宫
qq_53269123的博客
01-26 471
本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。 下图给出了一个迷宫的平面图，其中标记为1 的为障碍，标记为0的为可以通行的地方。 010000 000100 001001 110000 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR的顺序通过迷宫， 一共1010步。其中D、U、L、RD、U、L、R分别表示向下、向上、向左、向右走。 对于下面...
java迷宫DFS
青荣的博客
05-12 736
package Date_5_12; import java.util.Scanner; //DFS 迷宫算法 public class maze_2 { static int[][] maze;//地图 static int x;//地图x向量 static int y;//地图y向量 static int[][] dis;//每个点的距离起点 pub...
《Thinking in Java》深度解析
《Thinking in Java》是一本全方位、深度解析Java编程的权威教材，无论你是想要深入理解Java的初学者，还是寻求提升的开发者，都能从中受益匪浅。通过实际编程练习和理论讲解，这本书将帮助你掌握Java的核心概念和...
评论 30
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Mymel_晗

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

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

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

打赏作者

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

抵扣说明：

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

余额充值