搜索 on Coder_Studio

BISHI100 【模板】二分图结构Ⅰ-A ‖ 染色判定：DFS

Mon, 09 Mar 2026 20:51:45 +0000

思路

求解代码

public static void main(String[] args) throws IOException {
        // 使用 BufferedReader 和 PrintWriter 提升大规模数据下的 I/O 效率
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取输入的第一行，包含两个整数n和m，分别表示顶点数和边数
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 顶点数
        int m = Integer.parseInt(strA[1]);  // 边数

        // 创建邻接表表示的无向图
        List<Integer>[] adj = new ArrayList[n + 1];
        for (int i = 1; i <= n; i++) {
            adj[i] = new ArrayList<>();
        }

        // 读取所有边的信息，构建无向图
        for (int i = 0; i < m; i++) {
            String[] edge = br.readLine().trim().split("\\s+");
            int u = Integer.parseInt(edge[0]);  // 边的一个端点
            int v = Integer.parseInt(edge[1]);  // 边的另一个端点
            adj[u].add(v);  // 添加边到邻接表
            adj[v].add(u);  // 无向图，双向添加
        }

        // color数组用于记录每个顶点的颜色，0表示未染色，1和2表示两种不同的颜色
        int[] color = new int[n + 1];
        boolean flag = true;  // 标记是否为二分图

        // 使用队列实现BFS
        Queue<Integer> queue = new LinkedList<>();

        // 从顶点1开始染色，并将其加入队列
        queue.add(1);
        color[1] = 1;

        // BFS遍历图
        while (!queue.isEmpty()) {

            int cur = queue.poll();  // 取出队首顶点

            // 遍历当前顶点的所有邻接顶点
            for (int neighbor : adj[cur]) {

                // 如果邻接顶点未被染色
                if (color[neighbor] == 0) {

                    // 将邻接顶点染成与当前顶点不同的颜色
                    color[neighbor] = 3 - color[cur];
                    queue.add(neighbor);  // 将邻接顶点加入队列
                } else if (color[neighbor] == color[cur]) {
                    // 如果邻接顶点与当前顶点颜色相同，则不是二分图
                    flag = false;
                    break;
                }
            }
        }

        // 输出结果：如果是二分图输出"YES"，否则输出"NO"
        out.println(flag ? "YES" : "NO");
        // 刷新输出缓冲区，确保所有输出都被写入
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

【DFS+剪枝】BISHI91 拼接木棍

Wed, 04 Mar 2026 22:20:09 +0000

思路

求解代码

// n: 小木棒总数, sum: 所有木棒总长度, targetL: 目标原始长度, numbers: 目标原始木棒根数
    private static int n, sum, targetL, numbers;
    private static Integer[] a; // 存储砍断后的小木棒长度

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        n = Integer.parseInt(br.readLine().trim());
        String[] s = br.readLine().trim().split("\\s+");
        a = new Integer[n];
        boolean[] used = new boolean[n]; // 标记每根小木棒是否已被乔治使用
        sum = 0;
        int maxL = 0;

        for (int i = 0; i < n; i++) {
            a[i] = Integer.parseInt(s[i]);
            sum += a[i];
            maxL = Math.max(maxL, a[i]); // 原始长度至少要等于最长的那根小木棒
        }

        // 【剪枝优化 1】：降序排序。
        // 优先尝试长木棒。因为长木棒对位置要求更苛刻，如果它拼不通，能更早触发回溯。
        Arrays.sort(a, (x1, x2) -> (x2 - x1));

        // 枚举原始木棒可能的长度 targetL
        // 范围：从最长的那根开始，直到所有木棒的总和
        for (targetL = maxL; targetL <= sum; targetL++) {

            // 【条件约束】：原始长度必须能被总长度整除，否则乔治不可能拼成同样长的木棒
            if (sum % targetL != 0) {
                continue;
            }

            numbers = sum / targetL; // 计算在当前 targetL 下应该拼出多少根

            // 尝试拼凑，初始：已完成0根，当前长度0，从第0个小木棒开始找
            if (dfs(0, 0, 0, used)) {
                out.println(targetL); // 找到第一个可行的最小长度，即为答案
                break;
            }
        }
        out.flush();
        out.close();
        br.close();
    }

    /**
     * DFS 拼凑过程
     *
     * @param completed 已完整拼好的原始木棒根数
     * @param currentL  当前正在拼的那根原始木棒已经达到的长度
     * @param idx       为了避免重复组合，从数组的哪一个下标开始挑选下一根小木棒
     * @param used      使用情况记录
     */
    private static boolean dfs(int completed, int currentL, int idx, boolean[] used) {
        // 【递归出口】：如果乔治拼好了所有原始木棒，大功告成
        if (completed == numbers) {
            return true;
        }

        // 如果当前这根拼满了，开启下一根木棒的拼凑
        if (currentL == targetL) {
            return dfs(completed + 1, 0, 0, used);
        }

        for (int i = idx; i < n; i++) {
            // 如果这根用过了，或者放进去就超过了目标长度，跳过
            if (used[i] || currentL + a[i] > targetL) {
                continue;
            }

            // 【做选择】：尝试放这根木棒
            used[i] = true;
            if (dfs(completed, currentL + a[i], i + 1, used)) {
                return true;
            }

            // 【撤销选择】：刚才的尝试失败了，拿出来
            used[i] = false;

            // --- 核心剪枝策略 (极其关键) ---

            // 【剪枝优化 2】：首棒失败判定
            // 如果此时 currentL 为 0，说明我们正在尝试拼一根新木棒的第一部分。
            // 如果第一部分用这根最长的木棒都拼不出来，那后面更拼不出来了。

            // 【剪枝优化 3】：末棒失败判定
            // 如果加上这根木棒刚好填满了 targetL，但在后续递归中失败了，
            // 说明用这根刚好填满的方案不行，那么换用几根更碎的小木棒来填这个坑也肯定不行。
            if (currentL == 0 || currentL + a[i] == targetL) {
                return false;
            }

            // 【剪枝优化 4】：去重剪枝
            // 如果当前长度的木棒不行，那后面相同长度的木棒也肯定不行，直接跳过。
            while (i + 1 < n && a[i + 1].equals(a[i])) {
                i++;
            }
        }
        return false;
    }

BISHI90 【模板】记忆化搜索

Wed, 04 Mar 2026 20:51:44 +0000

思路

求解代码

 private static final int MOD = 1000000007;
    private static long[][][] memory = new long[101][101][101];

    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入，使用PrintWriter输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


        int T = Integer.parseInt(br.readLine().trim());

        while (T-- > 0) {
            String[] s = br.readLine().trim().split("\\s+");
            int a = Integer.parseInt(s[0]);
            int b = Integer.parseInt(s[1]);
            int c = Integer.parseInt(s[2]);
            out.println(solve(a, b, c));
        }


        // 刷新输出流，确保所有输出都被写入
        out.flush();
        // 关闭输出流，释放资源
        out.close();
        // 关闭输入流，释放资源
        br.close();
    }

    /**
     * 这是一个递归求解函数，使用记忆化技术来优化性能
     *
     * @param a 第一个参数
     * @param b 第二个参数
     * @param c 第三个参数
     * @return 返回计算结果，类型为long
     */
    private static long solve(int a, int b, int c) {
        // 如果任一参数小于等于0，返回1
        if (a <= 0 || b <= 0 || c <= 0) {
            return 1;
        }

        // 如果结果已经计算过并存储在memory中，直接返回存储的结果
        if (memory[a][b][c] != 0) {
            return memory[a][b][c];
        }

        long res; // 用于存储计算结果

        // 当a<b且b<c时，使用特定的递归公式计算
        if (a < b && b < c) {
            res = (solve(a, b, c - 1) + solve(a, b - 1, c - 1)) % MOD;
            res = (res - solve(a, b - 1, c) + MOD) % MOD;
        } else {
            res = (solve(a - 1, b, c) + solve(a - 1, b - 1, c)) % MOD;
            res = (res + solve(a - 1, b, c - 1)) % MOD;
            res = (res - solve(a - 1, b - 1, c - 1) + MOD) % MOD;
        }
        return memory[a][b][c] = res;
    }

【BFS】BISHI84 时津风的资源收集

Sun, 01 Mar 2026 20:38:54 +0000

思路

求解代码

// 定义一个静态数组dist，用于存储从数字10到其他数字的最小步数
    private static int[] dist = new int[301];

    public static void main(String[] args)throws IOException{
        // 调用bfs方法计算最小步数
        bfs();
        // 初始化输入输出流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        while (T-- >0){
            // 读取一行输入并分割成字符串数组
            String[] str = br.readLine().trim().split("\\s+");
            // 将字符串数组转换为四个整数
            int a = Integer.parseInt(str[0]);
            int b = Integer.parseInt(str[1]);
            int c = Integer.parseInt(str[2]);
            int d = Integer.parseInt(str[3]);

            // 计算四个数字的最小步数之和
            int ans = dist[a]+dist[b]+dist[c]+dist[d];
            // 输出结果
            out.println(ans);
        }
        // 刷新并关闭输出流
        out.flush();
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 使用BFS算法计算从数字10到其他数字的最小步数
     * 可以进行的操作包括：+1, -1, +10, -10, +100, -100
     * 特殊情况：可以直接跳到数字10或300
     */
    private static void bfs(){
        // 初始化dist数组，-1表示未访问
        Arrays.fill(dist,-1);
        // 创建队列用于BFS遍历
        Queue<Integer> queue = new LinkedList<>();

        // 设置起点数字10的步数为0
        dist[10]=0;
        // 将起点加入队列
        queue.add(10);
        // 定义可能的操作数组
        int[] ops = {1,-1,10,-10,100,-100};

        // 当队列不为空时继续遍历
        while (!queue.isEmpty()){
            // 取出队首元素
            int u = queue.poll();

            // 创建邻居列表
            List<Integer> neighbors = new ArrayList<>();

            // 应用所有可能的操作生成邻居
            for(int op:ops){
                neighbors.add(u+op);
            }

            // 添加特殊邻居：10和300
            neighbors.add(10);
            neighbors.add(300);

            // 遍历所有邻居
            for(int v:neighbors){
                // 如果邻居在有效范围内且未被访问过
                if(v>=10&&v<=300&&dist[v]==-1){
                    // 更新步数
                    dist[v]=dist[u]+1;
                    // 将邻居加入队列
                    queue.add(v);
                }
            }
        }
    }

【回溯】BISHI83 迷宫问题

Sat, 28 Feb 2026 22:45:36 +0000

思路

求解代码

private static List<int[]> path = new ArrayList<>();

    /**
     * 主方法，处理输入输出并调用回溯算法
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {
        // 创建输入输出缓冲流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割并转换为高度h和宽度w
        String[] strA = br.readLine().trim().split("\\s+");

        // 解析网格的高度和宽度
        int h = Integer.parseInt(strA[0]);
        int w = Integer.parseInt(strA[1]);

        // 创建网格数组和访问标记数组
        int[][] grid = new int[h][w];
        boolean[][] visited = new boolean[h][w];

        // 读取网格数据
        for (int i = 0; i < h; i++) {
            // 读取一行输入并分割
            String[] str = br.readLine().trim().split("\\s+");
            // 填充网格数据
            for (int j = 0; j < w; j++) {
                grid[i][j] = Integer.parseInt(str[j]);
            }
        }

        // 从起点(0,0)开始回溯
        backtrack(grid, h, w, 0, 0, visited);

        // 输出路径
        for (int[] pos : path) {
            out.println("(" + pos[0] + "," + pos[1] + ")");
        }

        // 刷新并关闭输出流和输入流
        out.flush();
        out.close();
        br.close();

    }

    /**
     * 使用回溯算法在网格中寻找路径
     *
     * @return 如果找到从起点到终点的路径则返回true，否则返回false
     */
    private static boolean backtrack(int[][] grid, int h, int w, int i, int j, boolean[][] visted) {
        // 检查当前位置是否有效：是否在网格范围内、是否是障碍物、是否已经访问过
        if (i < 0 || i >= h || j < 0 || j >= w || grid[i][j] == 1 || visted[i][j]) {
            return false;
        }

        // 标记当前位置为已访问，并将当前位置添加到路径中
        visted[i][j] = true;
        path.add(new int[]{i, j});

        // 如果当前位置是终点，则返回true
        if (i == h - 1 && j == w - 1) {
            return true;
        }

        // 定义四个方向：上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // 尝试向四个方向移动
        for (int k = 0; k < 4; k++) {
            // 递归调用backtrack方法，如果找到路径则返回true
            if (backtrack(grid, h, w, i + dx[k], j + dy[k], visted)) {
                return true;
            }
        }

        // 如果四个方向都无法继续前进，则回溯：从路径中移除当前位置
        path.remove(path.size() - 1);
        return false;
    }

【BFS】BISHI82 没挡住洪水

Sat, 28 Feb 2026 21:17:35 +0000

思路

求解代码


    /**
     * 主方法：处理吴铭市地图数据并统计被完全淹没的区域数量
     *
     * 业务逻辑：
     * 1. 读取 N*N 的城市地图。
     * 2. 通过遍历寻找每一个独立的“空地区域”（由 '#' 组成的四连通块）。
     * 3. 对每个区域进行洪水上涨模拟判定。
     *
     * @param args 命令行参数
     * @throws IOException IO异常处理
     */
    public static void main(String[] args) throws IOException {
        // 使用高效流读取地图数据与输出结果
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取地图尺寸 N
        int N = Integer.parseInt(br.readLine().trim());
        // grid: 地图矩阵，'.' 为已淹没，'#' 为空地
        char[][] grid = new char[N][N];
        // visit: 标记当前空地是否已被抗灾委员会统计过
        boolean[][] visit = new boolean[N][N];

        // 加载吴铭市当前受灾地图
        for (int i = 0; i < N; i++) {
            grid[i] = br.readLine().trim().toCharArray();
        }

        // ans: 记录洪水上涨一天后，完全消失的空地区域总数
        int ans = 0;

        // 逐格扫描地图
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                // 发现一块新的且未统计过的空地区域
                if (grid[i][j] == '#' && !visit[i][j]) {
                    /**
                     * 执行 BFS 模拟：
                     * 若该区域内所有格子在明天都会被淹没（即 bfs 返回 false），
                     * 则该区域属于“完全淹没区域”，计数加一。
                     */
                    if (!bfs(grid, N, i, j, visit)) {
                        ans++;
                    }
                }
            }
        }

        // 输出统计结果并释放资源
        out.println(ans);
        out.flush();
        out.close();
        br.close();
    }

    /**
     * 使用广度优先搜索 (BFS) 判定一个空地区域在洪水上涨后是否能“存活”
     *
     * 判定核心：
     * 一个区域能存活，当且仅当该区域内【至少有一个】格子是安全的。
     * 安全格子的定义：其上下左右四个相邻方向全部都是空地 '#'，洪水无法直接上涨淹没它。
     *
     * @param grid  城市地图矩阵
     * @param N     地图尺寸
     * @param i     区域起始点行坐标
     * @param j     区域起始点列坐标
     * @param visit 访问标记数组
     * @return 如果该区域上涨后仍有残留（不完全消失）返回 true，否则返回 false
     */
    private static boolean bfs(char[][] grid, int N, int i, int j, boolean[][] visit) {
        Queue<int[]> queue = new LinkedList<>();
        // 将当前区域的起点加入队列并标记
        queue.add(new int[]{i, j});
        visit[i][j] = true;

        // areaSurvived: 标识整个区域是否能存活（只要有一个格子不被淹，即为 true）
        boolean areaSurvived = false;

        // 四联通方向向量
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            int x = cur[0];
            int y = cur[1];

            // flag: 检查当前格子 (x, y) 是否为“避风港”
            // 默认假设它是安全的（四周无洪水 '.'）
            boolean flag = true;

            // 扫描当前格子的四周
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                // 如果邻居越界或者是洪水 '.'，则当前格子明早会被淹没
                if (nextX < 0 || nextX >= N || nextY < 0 || nextY >= N || grid[nextX][nextY] == '.') {
                    flag = false;
                    break;
                }
            }

            // 如果发现当前格子四周都是空地，它将保证该区域不被完全淹没
            if (flag) {
                areaSurvived = true;
            }

            // 继续探索该区域的其他空地格子
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                // 确保在地图范围内，且是同一区域的未访问空地
                if (nextX >= 0 && nextX < N && nextY >= 0 && nextY < N && grid[nextX][nextY] == '#' && !visit[nextX][nextY]) {
                    visit[nextX][nextY] = true;
                    queue.add(new int[]{nextX, nextY});
                }
            }
        }

        // 返回该区域是否完全消失
        return areaSurvived;
    }

【BFS】BISHI81 剪纸游戏

Fri, 27 Feb 2026 21:15:34 +0000

思路

求解代码

/**
     * 主方法，用于读取输入数据并处理网格问题
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出的IO异常
     */
    public static void main(String[] args) throws IOException {

        // 使用BufferedReader读取输入流
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        // 使用PrintWriter输出结果
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入并分割成字符串数组
        String[] str = br.readLine().trim().split("\\s+");
        // 解析网格的行数n
        int n = Integer.parseInt(str[0]);
        // 解析网格的列数m
        int m = Integer.parseInt(str[1]);

        // 创建n行m列的字符网格
        char[][] grid = new char[n][m];

        // 逐行读取网格数据
        for (int i = 0; i < n; i++) {
            // 将每行字符串转换为字符数组存入网格
            grid[i] = br.readLine().toCharArray();
        }

        // 创建n行m列的访问标记数组，初始值都为false
        boolean[][] visit = new boolean[n][m];
        // 初始化答案计数器
        int ans = 0;

        // 遍历网格的每个单元格
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前单元格是'.'且未被访问过
                if (grid[i][j] == '.' && !visit[i][j]) {
                    // 使用BFS方法处理，如果返回true则增加答案计数
                    if (bfs(grid, n, m, i, j, visit)) {
                        ans++;
                    }

                }
            }
        }
        // 输出最终结果
        out.println(ans);
        // 刷新输出流
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();

    }


    /**
     * 使用广度优先搜索(BFS)算法遍历连通区域，并判断该连通区域是否为矩形
     *
     * @param grid  二维字符网格，其中'.'表示可走区域
     * @param n     网格的行数
     * @param m     网格的列数
     * @param i     起始点的行坐标
     * @param j     起始点的列坐标
     * @param visit 记录访问状态的二维数组
     * @return 如果连通区域是完整的矩形则返回true，否则返回false
     */
    private static boolean bfs(char[][] grid, int n, int m, int i, int j, boolean[][] visit) {
        // 使用队列进行BFS遍历
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        visit[i][j] = true;  // 标记起始点为已访问

        // 记录连通区域的最小和最大x、y坐标
        int minX = i, maxX = i;
        int minY = j, maxY = j;

        // 记录连通区域中点的数量
        int count = 0;

        // 定义四个方向的偏移量：上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // BFS遍历连通区域
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();  // 取出队列中的当前点
            int x = cur[0];
            int y = cur[1];

            count++;  // 增加连通区域点计数

            // 更新连通区域的边界
            minX = Math.min(minX, x);
            maxX = Math.max(maxX, x);
            minY = Math.min(minY, y);
            maxY = Math.max(maxY, y);

            // 遍历四个方向
            for (int k = 0; k < 4; k++) {
                int nextX = x + dx[k];
                int nextY = y + dy[k];

                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && grid[nextX][nextY] == '.' && !visit[nextX][nextY]) {
                    visit[nextX][nextY] = true;
                    queue.add(new int[]{nextX, nextY});
                }
            }

        }

        // 判断是否填满整个区域
        // 当count等于整个区域的格子数量时，返回true，表示已填满
        // 整个区域的格子数量计算公式为：(maxX-minX+1) * (maxY-minY+1)
        return count == (maxX - minX + 1) * (maxY - minY + 1);
    }

【BFS-方向数组】BISHI80 走迷宫-方向数组

Fri, 27 Feb 2026 20:18:34 +0000

思路

求解代码

 /**
     * 主方法，处理输入输出并调用BFS算法
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取输入，使用PrintWriter输出
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，分割成字符串数组并解析为整数n和m
        String[] strA = br.readLine().trim().split("\\s+");
        int n = Integer.parseInt(strA[0]);  // 行数
        int m = Integer.parseInt(strA[1]);  // 列数

        // 读取第二行输入，分割成字符串数组并解析为起点和终点的坐标
        String[] strB = br.readLine().trim().split("\\s+");
        int xs = Integer.parseInt(strB[0]) - 1;  // 起点x坐标（转换为0-based索引）
        int ys = Integer.parseInt(strB[1]) - 1;  // 起点y坐标（转换为0-based索引）
        int xt = Integer.parseInt(strB[2]) - 1;  // 终点x坐标（转换为0-based索引）
        int yt = Integer.parseInt(strB[3]) - 1;  // 终点y坐标（转换为0-based索引）

        // 读取n行输入，构建二维字符数组grid表示地图
        char[][] grid = new char[n][m];
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim().toCharArray();
        }


        // 调用BFS方法计算最短路径长度，并将结果输出
        out.println(bfs(grid, n, m, xs, ys, xt, yt));
        // 刷新输出流，确保所有内容都被写出
        out.flush();
        // 关闭输出流和输入流
        out.close();
        br.close();

    }

    /**
     * 使用广度优先搜索(BFS)算法计算从起点到终点的最短路径
     *
     * @param grid 二维字符数组，表示网格地图，'.'表示可走的路径
     * @param n    网格的行数
     * @param m    网格的列数
     * @param xs   起点的x坐标
     * @param ys   起点的y坐标
     * @param xt   终点的x坐标
     * @param yt   终点的y坐标
     * @return 从起点到终点的最短距离，如果无法到达则返回-1
     */
    private static int bfs(char[][] grid, int n, int m, int xs, int ys, int xt, int yt) {
        // 如果起点和终点相同，直接返回0
        if (xs == xt && ys == yt) {
            return 0;
        }

        // 初始化距离数组，-1表示未访问过
        int[][] distance = new int[n][m];
        for (int i = 0; i < n; i++) {
            Arrays.fill(distance[i], -1);
        }

        // 使用队列实现BFS，存储待访问的节点坐标
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{xs, ys});
        distance[xs][ys] = 0;  // 起点到自身的距离为0

        // 定义四个方向的偏移量，分别表示上、下、左、右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        // BFS遍历
        while (!queue.isEmpty()) {
            // 取出队列中的当前节点
            int[] cur = queue.poll();

            int x = cur[0];
            int y = cur[1];

            // 遍历四个方向
            for (int i = 0; i < 4; i++) {
                // 计算下一个节点的坐标
                int nextX = x + dx[i];
                int nextY = y + dy[i];

                // 检查下一个节点是否在网格范围内，且是可走的路径，且未被访问过
                if (nextX >= 0 && nextX < n && nextY >= 0 && nextY < m && grid[nextX][nextY] == '.' && distance[nextX][nextY] == -1) {
                    // 更新距离
                    distance[nextX][nextY] = distance[x][y] + 1;

                    // 如果到达终点，返回距离
                    if (nextX == xt && nextY == yt) {
                        return distance[nextX][nextY];
                    }

                    // 将下一个节点加入队列
                    queue.add(new int[]{nextX, nextY});
                }
            }
        }
        // 如果无法到达终点，返回-1
        return -1;
    }

BISHI79 取数游戏

Thu, 26 Feb 2026 21:45:07 +0000

思路

求解代码

private static int N, M;  // 网格的行数和列数
    private static int[][] grid;  // 存储网格数据的二维数组
    private static boolean[][] used;  // 标记网格位置是否被使用过的二维数组
    private static long ans;  // 存储最终答案的最大值

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader从标准输入读取数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter向标准输出写入数据
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));


        // 读取测试用例数量
        int T = Integer.parseInt(br.readLine().trim());

        // 处理每个测试用例
        for (int i = 0; i < T; i++) {
            String[] str = br.readLine().split("\\s+");
            N = Integer.parseInt(str[0]);
            M = Integer.parseInt(str[1]);

            grid = new int[N][M];  // 初始化网格数组
            used = new boolean[N][M];  // 初始化使用标记数组
            ans = 0;  // 重置答案为0

            // 读取网格数据
            for (int j = 0; j < N; j++) {
                String[] gridStr = br.readLine().trim().split("\\s+");
                for (int k = 0; k < M; k++) {
                    grid[j][k] = Integer.parseInt(gridStr[k]);  // 将字符串转换为整数存入网格
                }
            }
            backtrack(0, 0);  // 从第一个位置开始回溯
            out.println(Math.max(ans, 0));  // 输出最大答案，至少为0
        }

        out.flush();  // 刷新输出缓冲区
        out.close();  // 关闭输出流
        br.close();  // 关闭输入流


    }


    /**
     * 回溯算法方法，用于在网格中寻找最大可能值
     *
     * @param index  当前处理的位置索引，从0到N*M-1
     * @param curAns 当前累计的答案值
     */
    private static void backtrack(int index, long curAns) {
        // 基本情况：如果已经处理完所有网格位置
        if (index == N * M) {
            // 更新最大答案值
            ans = Math.max(ans, curAns);
            return;
        }

        // 计算当前索引对应的行和列
        int row = index / M;  // 计算当前行号
        int col = index % M;  // 计算当前列号

        // 情况1：不选择当前网格位置，直接处理下一个位置
        backtrack(index + 1, curAns);

        // 情况2：如果当前位置可以安全选择
        if (isSafe(row, col)) {
            // 标记当前位置为已使用
            used[row][col] = true;
            // 选择当前位置，累加其值并处理下一个位置
            backtrack(index + 1, curAns + grid[row][col]);
            // 回溯：撤销当前位置的使用标记
            used[row][col] = false;
        }
    }

    /**
     * 检查指定位置是否安全，即其周围8个方向（包括自身）是否都没有被使用过
     *
     * @param row 当前行索引
     * @param col 当前列索引
     * @return 如果周围8个方向都没有被使用过，返回true；否则返回false
     */
    private static boolean isSafe(int row, int col) {
        // 遍历当前位置的周围8个方向（包括自身）
        for (int drow = -1; drow <= 1; drow++) {
            for (int dcol = -1; dcol <= 1; dcol++) {
                // 计算下一个位置的行索引
                int nextRow = row + drow;
                // 计算下一个位置的列索引
                int nextCol = col + dcol;

                // 检查下一个位置是否在有效范围内
                if (nextRow >= 0 && nextRow < N && nextCol >= 0 && nextCol < M) {
                    // 如果下一个位置已经被使用过，则返回false
                    if (used[nextRow][nextCol]) {
                        return false;
                    }
                }

            }
        }
        // 如果周围8个方向都没有被使用过，则返回true
        return true;
    }

【DFS】BISHI77数水坑

Wed, 25 Feb 2026 22:45:37 +0000

思路

求解代码

 /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        int ans = 0;  // 用于记录找到的'W'的数量

        // 遍历网格中的每个元素
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                // 如果当前元素是'W'，则增加计数器并执行深度优先搜索
                if (gridStr[i][j] == 'W') {
                    ans++;  // 增加计数器
                    dfs(gridStr, i, j);  // 执行深度优先搜索，标记相邻的'W'
                }

            }
        }

        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索(DFS)方法，用于遍历网格中的连通区域
     *
     * @param grid 二维字符网格
     * @param i    当前处理的行坐标
     * @param j    当前处理的列坐标
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 如果当前格子是'.'，表示已经是访问过的格子，直接返回
        if (grid[i][j] == '.') {
            return;
        }

        // 将当前格子标记为已访问（用'.'表示）
        grid[i][j] = '.';

        // 遍历当前格子的8个相邻方向（包括对角线方向）
        for (int di = -1; di <= 1; di++) {
            for (int dj = -1; dj <= 1; dj++) {
                // 跳过当前格子本身
                if (di == 0 && dj == 0) {
                    continue;
                }
                // 递归处理相邻格子
                dfs(grid, i + di, j + dj);
            }
        }

    }

【DFS】BISHI76 迷宫寻路

Wed, 25 Feb 2026 21:45:53 +0000

思路

求解代码

private static String ans = "No";

    /**
     * 主方法，程序的入口点
     *
     * @param args 命令行参数
     * @throws IOException 可能抛出IO异常
     */
    public static void main(String[] args) throws IOException {
        // 使用BufferedReader读取标准输入，用于高效读取输入数据
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        // 使用PrintWriter输出结果，提供高效的输出功能
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        // 读取第一行输入，并按空白字符分割成字符串数组
        String[] strA = br.readLine().trim().split("\\s+");


        // 解析第一行输入中的两个整数，n和m
        int n = Integer.parseInt(strA[0]);  // 网格的行数
        int m = Integer.parseInt(strA[1]);  // 网格的列数

        // 创建字符串数组用于存储网格数据
        String[] grid = new String[n];
        // 创建二维字符数组，用于存储网格的字符表示
        char[][] gridStr = new char[n][m];

        // 读取网格数据
        for (int i = 0; i < n; i++) {
            grid[i] = br.readLine().trim();  // 读取一行并去除首尾空白
            gridStr[i] = grid[i].toCharArray();  // 将字符串转换为字符数组
        }

        // 从起点(0,0)开始深度优先搜索
        dfs(gridStr, 0, 0);
        // 输出结果
        out.println(ans);

        // 刷新输出流，确保所有数据都被写出
        out.flush();
        // 关闭输出流
        out.close();
        // 关闭输入流
        br.close();
    }

    /**
     * 深度优先搜索（DFS）方法，用于在二维网格中寻找从起点到终点的路径
     *
     * @param grid 二维字符网格，包含可走的路径和障碍物
     * @param i    当前搜索的行索引
     * @param j    当前搜索的列索引
     */
    private static void dfs(char[][] grid, int i, int j) {
        // 检查当前坐标是否超出网格边界
        if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
            return;
        }

        // 检查当前单元格是否是障碍物（已访问过的标记为'#'）
        if (grid[i][j] == '#') {
            return;
        }

        // 检查是否到达终点（右下角）
        if (i == grid.length - 1 && j == grid[0].length - 1) {
            ans = "Yes";  // 找到路径，设置答案为"Yes"
            return;
        }

        // 标记当前单元格为已访问（使用'#'作为标记）
        grid[i][j] = '#';
        // 向上搜索
        dfs(grid, i - 1, j);
        // 向下搜索
        dfs(grid, i + 1, j);
        // 向左搜索
        dfs(grid, i, j - 1);
        // 向右搜索
        dfs(grid, i, j + 1);
    }

【BISHI15】小红的夹吃棋

Fri, 06 Feb 2026 23:20:05 +0000

求解代码

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(in.nextToken());

        for (int i = 0; i < t; i++) {
            char[][] board = new char[3][3];

            for (int j = 0; j < 3; j++) {
                String s = br.readLine().trim();
                board[j] = s.toCharArray();
            }

            boolean redEat = hasEat(board, '*');
            boolean purpleEat = hasEat(board, 'o');

            if (redEat && !purpleEat) {
                out.println("yukari");
            } else if (!redEat && purpleEat) {
                out.println("kou");
            } else {
                out.println("draw");
            }
        }

        out.flush();
        out.close();
        br.close();
    }

    private static boolean hasEat(char[][] board, char piece) {
        char opponent = (piece == '*') ? 'o' : '*';

        //遍历 3 行（行索引 0-2），
        // 仅检查 “该行中间列（索引 1）是己方棋子，
        // 左右列（索引 0、2）全是对方棋子”
        for (int row = 0; row < 3; row++) {
            if (board[row][1] == piece &&
                    board[row][0] == opponent &&
                    board[row][2] == opponent) {
                return true;
            }
        }

        //遍历 3 列（列索引 0-2），
        // 仅检查 “该列中间行（索引 1）是己方棋子，
        // 上下行（索引 0、2）全是对方棋子”
        for (int col = 0; col < 3; col++) {
            if (board[1][col] == piece &&
                    board[0][col] == opponent &&
                    board[2][col] == opponent) {
                return true;
            }
        }

        return false;
    }

小贴士

逐行读取 3 行字符串时需要用br.readLine().trim()，可以避免StringTokenizer的分割符问题，其实这题用in.nextToken()还过不了。

【BISHI12】元素方碑

Fri, 06 Feb 2026 00:32:53 +0000

求解代码

public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer in = new StringTokenizer(br.readLine());
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        
            int t = Integer.parseInt(in.nextToken());

            for(int i=0;i<t;i++){
                in = new StringTokenizer(br.readLine());
                int n = Integer.parseInt(in.nextToken());

                int[] nums = new int[n];
                int count = 0;

                in = new StringTokenizer(br.readLine());
                for(int j=0;j<n;j++){
                    nums[j]=Integer.parseInt(in.nextToken());
                    count+=nums[j];
                }


                if(count%n!=0){
                    out.println("NO");
                }else{
                    /**
                     * 问题转化为：能否通过题目允许的操作，将所有偏差值变为0。
                     */
                    for(int j=0;j<n;j++){
                        nums[j]-=(count/n);
                    }

                    /**
                     * 将j-1位置的所有偏差值，全部累加到j+1位置，然后将j-1置为 0；
                     * 说人话就是模拟能量从左向右转移，清空左侧方碑的偏差。
                     */
                    for(int j =1;j<n-1;j++){
                        nums[j+1]+=nums[j-1];
                        nums[j-1]=0;
                    }

                    boolean flag = true;


                    for(int j=0;j<n;j++){
                        if(nums[j]!=0){
                            flag=false;
                            break;
                        }

                    }
                    out.println(flag?"YES":"NO");
                }
            }
        
        out.flush();
        out.close();
        br.close();
   }

【二分法】在 D 天内送达包裹的能力

Tue, 03 Feb 2026 22:23:39 +0000

求解代码

public int shipWithinDays(int[] weights, int days) {
            int left = 0;
            int sum = 0;
            for (int weight : weights) {
                left = Math.max(left, weight);
                sum += weight;
            }
            int right = sum;

            while (left < right) {
                int mid = left + ((right - left) >> 1);

                if (f(weights, mid) <= days) {
                    // 满足天数要求：尝试更小的运载能力，收缩右边界
                    right = mid;
                } else {
                    // 不满足要求：必须增大运载能力，收缩左边界
                    left = mid + 1;
                }
            }
            return left;
        }

        private int f(int[] weights, int capacity) {
            int days = 0;
            for (int i = 0; i < weights.length;) {
                int cap = capacity;
                while (i < weights.length) {
                    // 装不下当前包裹，结束本批次运输
                    if (cap < weights[i]) {
                        break;
                    } else {
                        cap -= weights[i];
                    }
                    i++;
                }
                // 完成一趟运输，天数+1
                days++;
            }
            return days;
        }

【滑动窗口】最小覆盖子串

Mon, 26 Jan 2026 22:58:01 +0000

求解代码

    public String minWindow(String S, String T) {
        // 记录当前窗口中各字符的出现次数
        HashMap<Character, Integer> window = new HashMap<>();
        // 记录T中各字符需要的出现次数
        HashMap<Character, Integer> need = new HashMap<>();

        // 统计T中每个字符的出现次数
        for (char c : T.toCharArray()) {
            need.put(c, need.getOrDefault(c, 0) + 1);
        }

        int left = 0, right = 0; // 滑动窗口的左右指针，[left, right) 左闭右开区间
        int valid = 0; // 有效匹配数

        int start = 0, len = Integer.MAX_VALUE; // 记录最小窗口的起始下标和长度，初始len为无穷大

        // 右指针扩窗口 → 嵌套 左指针缩窗口
        while (right < S.length()) {
            char c = S.charAt(right); // 即将加入窗口的字符
            right++; // 右指针右移，扩大窗口（左闭右开，先取字符再移指针）

            // 若当前字符是T需要的字符，更新window表
            if (need.containsKey(c)) {
                window.put(c, window.getOrDefault(c, 0) + 1);
                // 当window中该字符的次数 == need中需要的次数时，有效匹配数+1
                if (window.get(c).equals(need.get(c))) {
                    valid++;
                }
            }

            // 当窗口满足条件（包含T所有字符），开始收缩左指针，找最小窗口
            while (valid == need.size()) {
                
                if (right - left < len) { // 若当前窗口长度更小，更新start和len
                    start = left; // 记录最小窗口的起始下标
                    len = right - left; // 记录最小窗口的长度（左闭右开，长度=right-left）
                }

                char d = S.charAt(left); // 即将移出窗口的字符
                left++; 

                // 若移出的字符是T需要的字符，更新window表和valid
                if (need.containsKey(d)) {
                    // 若移出前该字符的次数刚好满足need，移出后会不满足，有效匹配数-1
                    if (window.get(d).equals(need.get(d))) {
                        valid--;
                    }
                    window.put(d, window.get(d) - 1); // 窗口中该字符次数-1
                }
            }
        }

        // 若len仍为无穷大，说明无满足条件的窗口，返回空串；否则返回最小子串
        return len == Integer.MAX_VALUE ? "" : S.substring(start, start + len);
    }

小贴士

因为滑动窗口是左闭右开区间，所有len的计算不用+1。

DFS-字符串分割-数字字符串转化成IP地址

Fri, 23 Jan 2026 00:25:31 +0000

求解代码

ArrayList<String> ans = new ArrayList<>();
    public ArrayList<String> restoreIpAddresses (String s) {

        if(s==null||s.length()<4||s.length()>12){
            return ans;
        }
        StringBuilder sb = new StringBuilder();
        dfs(s,sb,0,0);
        return ans;
    }

    private void dfs(String s,StringBuilder sb,int step,int index){
        if(step==4){
            if(index==s.length()){
                ans.add(sb.toString());
            }
            return;
        }else{
            for(int i=index;i<index+3&&i<s.length();i++){
                String cur = s.substring(index,i+1);
                
                if(Integer.parseInt(cur)>255||(cur.length()>1&&cur.charAt(0)=='0')){
                    continue;
                }
                sb.append(cur);
                if(step<3){
                    sb.append('.');
                }
                dfs(s,sb,step+1,i+1);
                if(step<3){
                    sb.deleteCharAt(sb.length()-1);
                }
                sb.delete(sb.length()-cur.length(), sb.length());


            }
        }
    }

小贴士

sb.delete(sb.length()-cur.length(), sb.length())这行代码是删除字符串中「从sb.length()-cur.length()索引（包含）到sb.length()索引（不包含）」的所有字符，是一个左闭右开区间。

说人话就是：

删除 StringBuilder 中最后面的、长度等于 cur 的所有字符，也就是是把之前拼接的当前 IP 段 cur 从 sb 中删掉，恢复 sb 到拼接 cur 前的状态。

记忆化+递归-最小花费爬楼梯

Tue, 20 Jan 2026 00:50:13 +0000

求解代码

public int minCostClimbingStairs(int[] cost) {
        
        int n = cost.length;
        int[] memo = new int[n+1];
        Arrays.fill(memo, -1);
        return dp(cost,n, memo);

    }

    private int dp(int[] cost,int n,int[] memo){
        if(n==0||n==1){
            return 0;
        }

        if(memo[n]!=-1){
            return memo[n];
        }

        memo[n]=Math.min(dp(cost, n-1, memo)+cost[n-1],dp(cost, n-2, memo)+cost[n-2]);
        return memo[n];
    }

小贴士

所有的钱，都花在落脚的那一刻；跳的过程，一分钱不花。

动态规划=递归+记忆化存储-跳台阶

Mon, 19 Jan 2026 20:48:04 +0000

求解代码

public int jumpFloor(int number) {
        int[] memo = new int[number + 1];

        return dp(number, memo);
    }

    private int dp(int number,int[] memo){
        if(number<=2){
            return number;
        }
        

        if(memo[number]!=0){
            return memo[number];
        }

        memo[number]=dp(number-1, memo)+dp(number-2, memo);

        return memo[number];
    }

小贴士

1.要跳到第 n 级，最后一步只有两种可能：从 n-1 级跳 1 级上来、从 n-2 级跳 2 级上来，总方法数就是两者之和。

2.构建一个备忘录数组，用来缓存已经计算过的结果，数组下标对应台阶数，值对应该台阶的跳法数。

由于数组的默认值为0，0就表示该台阶的跳法数还未计算；

如果值≠0，就表示已经计算过，直接取值即可。

回溯-括号生成

Mon, 19 Jan 2026 00:24:24 +0000

求解代码

private ArrayList<String>  ans = new ArrayList<>();
    private void backtrack(int left,int right,StringBuilder sb){
        if(left==0&&right==0){
            ans.add(new String(sb));
            return;
        }

        if(left>right){
            return;
        }

        if(left<0||right<0){
            return;
        }
        sb.append('(');
        backtrack(left-1, right, sb);
        sb.deleteCharAt(sb.length()-1);

        sb.append(')');
        backtrack(left, right-1, sb);
        sb.deleteCharAt(sb.length()-1);
    }
    public ArrayList<String> generateParenthesis(int n) {
        StringBuilder sb = new StringBuilder();
        backtrack(n, n, sb);
        return ans;
    }

小贴士

对于一个合法的括号字符串组合，其任意位置的左括号数量都大于等于右括号数量。

回溯-N皇后问题

Mon, 19 Jan 2026 00:24:00 +0000

求解代码

    private int ans = 0;   
    public int Nqueen(int n) {
        int[] pos = new int[n];
        backtrack(n, 0, pos);
        return ans;
    }

    private boolean isValid(int[] pos,int row,int col){
        for(int i=0;i<row;i++){
            if(pos[i]==col||Math.abs(row-i)==Math.abs(col-pos[i])){
                return false;
            }
        }
        return true;
    }

    private void backtrack(int n,int row,int[] pos){
        if(row==n){
            ans++;
            return;
        }

        for(int i=0;i<n;i++){
            if(isValid(pos, row, i)){
                pos[row]=i;
                backtrack(n, row+1, pos);
            }
        }
    }

小贴士

1.pos[i]==col||Math.abs(row-i)==Math.abs(col-pos[i]这个校验逻辑为什么是这样？

主要是因为回溯是逐行递归，一行只放一个皇后，天然规避同行冲突，所以这里没有写i==row;

然后利用了对角线的数学判定公式：

两个皇后的【行号差值的绝对值】 = 【列号差值的绝对值】➡️必在同一条对角线上

2.在 N 皇后问题中，行不会重复选（遍历规则）、列不会重复选（校验规则），used数组的使命已经被替代，所以不需要写 used 数组。

3.本题的回溯为什么不需要显式写撤销代码？

做选择时只修改了当前层级专属的变量，且变量会被下一次循环自动覆盖，覆盖之后，旧值就消失了，相当于恢复成了原始状态。

DFS-矩阵最长递增路径

Mon, 19 Jan 2026 00:23:17 +0000

求解代码

private int m, n;

    private int dfs(int[][] matrix, int[][] dp, int i, int j) {
        // 记忆化：已经计算过该位置的最长路径，直接返回
        if (dp[i][j] != 0) {
            return dp[i][j];
        }
        
        dp[i][j]++;

        
        if (i - 1 >= 0 && matrix[i - 1][j] > matrix[i][j]) {
            dp[i][j] = Math.max(dp[i][j], dfs(matrix, dp, i - 1, j) + 1);
        }
        
        if (i + 1 < m && matrix[i + 1][j] > matrix[i][j]) {
            dp[i][j] = Math.max(dp[i][j], dfs(matrix, dp, i + 1, j) + 1);
        }
        
        if (j - 1 >= 0 && matrix[i][j - 1] > matrix[i][j]) {
            dp[i][j] = Math.max(dp[i][j], dfs(matrix, dp, i, j - 1) + 1);
        }
        
        if (j + 1 < n && matrix[i][j + 1] > matrix[i][j]) {
            dp[i][j] = Math.max(dp[i][j], dfs(matrix, dp, i, j + 1) + 1);
        }
        
        return dp[i][j];
    }

    public int solve(int[][] matrix) {
        
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }

        int ans = 0;
        m = matrix.length;
        n = matrix[0].length;
        
        int[][] dp = new int[m][n];

        // 遍历矩阵的每一个单元格，作为递增路径的起点
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                ans = Math.max(ans, dfs(matrix, dp, i, j));
            }
        }
        return ans;
    }

小贴士

dp[i][j]是以矩阵中第 i 行 j 列的单元格为起点的最长递增路径的长度。

如果计算过dp[i][j]，就会把结果存入数组，后续再递归到这个单元格时，可直接返回结果。

说说代码Math.max(dp[i][j], dfs(matrix, dp, i + 1, j) + 1)：

dp[i][j]是当前单元格「已经算出的最长路径长度」；

dfs(...) +1是当前单元格「走上下左右的某个方向能得到的路径长度」；

回溯+剪枝-字符串的排列

Sun, 18 Jan 2026 20:37:04 +0000

求解代码

ArrayList<String> ans = new ArrayList<>();
    public ArrayList<String> Permutation(String str) {

        StringBuilder sb = new StringBuilder();
        boolean[] used = new boolean[str.length()];
        char[] chs = str.toCharArray();
        Arrays.sort(chs);
        str = new String(chs);
        backtrack(str, sb, used);
        return ans;
    }

    private void backtrack(String str, StringBuilder sb, boolean[] used) {
        if (sb.length() == str.length()) {
            ans.add(new String(sb));
            return;
        }

        for (int i = 0; i < str.length(); i++) {
            if (used[i]) {
                continue;
            }
            if (i > 0 && str.charAt(i) == str.charAt(i - 1) && !used[i - 1]) {
                continue;
            }
            sb.append(str.charAt(i));
            used[i] = true;
            backtrack(str, sb, used);
            sb.deleteCharAt(sb.length() - 1);
            used[i] = false;

        }
    }

小贴士

这道题本质上跟【回溯】有重复项数字的全排列是一样的，都是【有重复项数字的全排列问题】，只不过从普通的数组环境迁移到了字符串环境，其实字符串本质上也是数组，字符数组嘛。

DFS-岛屿数量

Sun, 18 Jan 2026 05:00:00 +0000

求解代码

public int solve (char[][] grid) {
        int ans = 0;
        int m = grid.length,n =grid[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]=='1'){
                    ans++;
                    dfs(grid, i, j);
                }
            }
        }
        return ans;
    }

    private void dfs(char[][] grid,int i,int j){
        if(i<0||j<0||i>=grid.length||j>=grid[0].length){
            return;
        }


        if(grid[i][j]=='0'){
            return;
        }

        grid[i][j]='0';
        dfs(grid, i-1, j);
        dfs(grid, i+1, j);
        dfs(grid, i, j-1);
        dfs(grid, i, j+1);
    }

小贴士

1.这道题，发现一块陆地 grid[i][j]='1' 时，立刻把这块陆地，以及和它相连的所有陆地，全部修改为海水 '0'，这样做可以实现用原数组本身做访问标记，这样就不需要额外创建 boolean[][] used 数组了。

2.解释一下代码里是 看到1就ans++，为什么不会把同一块相连的 1 重复计数？

其实，ans++ 并不是见到 1 就加，而是什么呢？

是这样的，发现了一个全新的、独立的岛屿的起点，这个时候岛屿数量就会 + 1，我们还要注意紧跟的 dfs(grid,i,j) 。

这个dfs会把岛屿的起点所属的一整块相连的所有 1，全部永久变成 0，这么做就能够实现一个岛屿，只会触发 1 次 ans++

回溯-有重复项数字的全排列

Sun, 18 Jan 2026 04:30:00 +0000

求解代码

ArrayList<ArrayList<Integer>> ans  = new ArrayList<>();
    public ArrayList<ArrayList<Integer>> permuteUnique (int[] num) {
        ArrayList<Integer> track = new ArrayList<>();
        boolean[] used = new boolean[num.length];
        Arrays.sort(num);
        backtrack(num, track, used);
        return ans;
    }

    private void backtrack(int[] num,ArrayList<Integer> track,boolean[] used){
        if(track.size()==num.length){
            ans.add(new ArrayList<>(track));
            return;
        }

        for(int i=0;i<num.length;i++){
            if(used[i]){
                continue;
            }

            if(i>0&&num[i]==num[i-1]&&!used[i-1]){
                continue;
            }

            track.add(num[i]);
            used[i]=true;
            backtrack(num, track, used);
            track.remove(track.size()-1);
            used[i]=false;
        }
    }

小贴士

在代码层面，这道【有重复项数字的全排列问题】和【没有重复项数字的全排列问题】不同的就是增加了一个排序语句和一个if语句。

其中，排序是为了让重复元素相邻，后续只需要判断相邻的重复元素即可。

那下面的if语句为什么是!used [i-1] 才跳过呢？

这里可能有点绕，主要是因为：

如果当前元素和前一个元素重复，且前一个元素没被使用，那么选当前元素的所有递归分支，和选前一个元素的递归分支，是完全一模一样的！

直白一点就是，前一个重复元素都没选，你还选当前这个，纯属多此一举，还会制造重复，必须剪掉！

回溯-没有重复项数字的全排列

Sun, 18 Jan 2026 04:15:00 +0000

求解代码

 ArrayList<ArrayList<Integer>> ans = new ArrayList<>();

    public ArrayList<ArrayList<Integer>> permute (int[] num) {
        ArrayList<Integer> track = new ArrayList<>();
        boolean[] used = new boolean[num.length];
        backtrack(num,track,used);
        return ans;

    }

    private void backtrack(int[] num,ArrayList<Integer> track,boolean[] used){
        if(track.size()==num.length){
            ans.add(new ArrayList<>(track));
            return;
        }

        for(int i=0;i<num.length;i++){
            if(used[i]){
                continue;
            }
            track.add(num[i]);
            used[i]=true;
            backtrack(num,track,used);
            track.remove(track.size()-1);
            used[i]=false;
        }
    }

小贴士

回溯的核心是状态回退，也就是递归深入时修改的状态（比如本题的track、used），递归返回时必须恢复原状，只有这样才能保证下一轮循环的选择是干净的。

Leetcode200岛屿数量

Sat, 03 Jan 2026 22:25:01 +0000

题目分析

要区分二维矩阵中的每个1，需要将二维问题转化为一维编号问题。

如果矩阵有m列，位于第i行、第j列的元素对应的一维编号为i乘以m加j。

先将所有的1建成小集合，遍历矩阵，遇到1时，如果其左边或者上边有1则进行合并，最后统计并查集中集合的数量就是岛的数量。

代码求解

public static int numIslands(char[][] board){
		int n = board.length;
		int m = board[0].length;

		build(n,m,board);
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				if(board[i][j]=='1'){
					if(j>0&&board[i][j-1]=='1'){
						union(i,j,i,j-1);
					}

					if(i>0&&board[i-1][j]=='1'){
						union(i,j,i-1,j);
					}
				}
			}
		}
		return sets;
	}

	public static int MAXSIZE = 100001;
	public static int[] father = new int[MAXSIZE];
	public static int cols;
	public static int sets;

	public static void build(int n,int m,char[][] board){
		cols = m;
		sets = 0;
		for(int a=0;a<n;a++){
			for(int b=0,index;b<m;b++){
				if(board[a][b]=='1'){
					index = index(a,b);
					father[index]=index;
					sets++;
				}
			}
		}
	}

	public static int index(int a,int b){
		return a*cols+b;
	}

	public static int find(int i){
		if(i!=father[i]){
			father[i]=find(father[i]);
		}
		return father[i];
	}

	public static void union(int a,int b,int c,int d){
		int fx = find(index(a, b));
		int fy = find(index(c, d));
		if(fx!=fy){
			father[fx]=fy;
			sets--;
		}
	}

这道题告诉你-有时候-反着想-就对了

Sun, 21 Dec 2025 19:08:33 +0000

求解思路

这道题与其直接想"怎么分割数组"，不如先问"如果我规定每个子数组的和不能超过某个值 x，那最少需要分成几部分？"

通过这个反向思考，我们可以用二分搜索来找答案。

想象一下调节音量的过程，我们在 0 到数组总和之间不断试探一个"限制值"，每次尝试时都检查：

在这个限制下能否把数组分成不超过 k 个部分。

如果可以做到，说明这个限制还能再小一点，我们就往更小的方向试；

如果做不到，说明限制太严格了,我们就往更大的方向试。

这样一步步逼近,最终就能找到那个"恰好能分成 k 个部分"的最小限制值，这个值就是答案。

代码实现

public static int splitArray(int[] nums, int k) {
    // 计算数组总和，这是二分搜索的右边界
    long sum = 0;
    for (int num : nums) {
        sum += num;
    }
    
    long ans = 0;
    // 在 [0, sum] 区间进行二分搜索
    for (long l = 0, r = sum, m, need; l <= r;) {
        // 计算中点
        m = l + ((r - l) >> 1);
        
        // 关键：如果限制每部分和不超过 m，需要分成几个部分?
        need = f(nums, m);
        
        if (need <= k) {
            // 如果分成的部分数 <= k，说明 m 可行
            // 但可能还能更小，继续在左半边找
            ans = m;
            r = m - 1;
        } else {
            // 如果需要分成的部分 > k，说明 m 太小了
            // 需要增大限制，在右半边找
            l = m + 1;
        }
    }
    return (int) ans;
}

// 辅助函数：给定限制 limit，计算最少需要分成几个部分
public static int f(int[] arr, long limit) {
    int parts = 1;  // 至少需要 1 个部分
    int sum = 0;    // 当前部分的累加和
    
    for (int num : arr) {
        // 如果单个元素就超过限制，无法分割
        if (num > limit) {
            return Integer.MAX_VALUE;
        }
        
        // 如果加上当前元素会超过限制
        if (sum + num > limit) {
            parts++;      // 开启新的部分
            sum = num;    // 当前元素作为新部分的起始
        } else {
            sum += num;   // 继续累加到当前部分
        }
    }
    return parts;
}

如果觉得有帮助，欢迎点赞、关注、转发~

二分查找新玩法-不在数组里找-而在-可能的答案-里找

Sat, 20 Dec 2025 18:46:01 +0000

求解思路

这道题我们可以把速度的范围确定在1到最大堆的香蕉数量之间,因为速度最小是1(总得吃),最大也不需要超过最大堆的数量(再快也没意义)。

然后我们在这个范围内不断尝试中间值,对于每个速度计算需要多少小时吃完,

如果小于等于h小时说明这个速度可行,但我们要找最小的,所以继续往左半边找更小的速度;

如果超过h小时说明速度太慢了,就往右半边找更快的速度。

这样不断缩小范围,最终就能找到刚好满足条件的最小速度。

代码解析

public static int minEatingSpeed(int[] piles, int h) {
    // 确定速度的搜索范围[l,r]
    int l = 1;  // 最小速度为1
    int r = 0;
    for (int pile : piles) {
        r = Math.max(r, pile);  // 最大速度为最大堆的数量
    }
    
    // 在[l,r]区间内二分查找
    int ans = 0;
    int m = 0;
    while (l <= r) {
        m = l + ((r - l) >> 1);  // 计算中间速度,避免溢出
        
        if (f(piles, m) <= h) {
            // 当前速度可以在h小时内吃完
            ans = m;      // 记录答案
            r = m - 1;    // 尝试更小的速度
        } else {
            // 当前速度太慢,需要更快
            l = m + 1;
        }
    }
    return ans;
}

// 计算以speed速度吃完所有香蕉需要的小时数
public static long f(int[] piles, int speed) {
    long ans = 0;
    for (int pile : piles) {
        // 向上取整:(pile + speed - 1) / speed
        // 例如:pile=11,speed=4 → (11+3)/4=3小时
        ans += (pile + speed - 1) / speed;
    }
    return ans;
}

如果觉得有帮助，欢迎点赞、关注、转发~

技能杀怪的最优策略

Mon, 17 Nov 2025 20:49:07 +0000

求解思路

这道题采用全排列枚举加递归回溯的思想，通过交换技能位置来尝试所有可能的使用顺序。

递归函数 f(n, i, r) 表示有n个技能、当前考虑第i个位置、怪物剩余血量为r时最少需要多少个技能才能击杀。

当怪物血量降至0以下时返回已使用的技能数，当技能用完但怪物仍存活则返回无效值 Integer.MAX_VALUE。

核心逻辑是在每个位置枚举将后面哪个技能交换到当前位置使用，根据怪物当前血量与技能阈值的关系计算伤害（血量大于阈值造成普通伤害，否则双倍），然后递归求解后续状态，通过 Math.min 不断更新最优解，最后通过回溯恢复现场以便尝试其他排列方案。

完整实现代码

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class Main{
    
    // 最大技能数量
    public static int MAXN = 11;
    // kill[i]：第i个技能的伤害值
    public static int[] kill = new int[MAXN];
    // blood[i]：第i个技能的血量阈值
    public static int[] blood = new int[MAXN];
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(br);
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        
        // 读取测试用例数量
        while (in.nextToken() != StreamTokenizer.TT_EOF) {
            int t = (int) in.nval;
            
            // 处理每个测试用例
            for (int i = 0; i < t; i++) {
                in.nextToken();
                int n = (int) in.nval; // 技能数量
                in.nextToken();
                int m = (int) in.nval; // 怪物初始血量
                
                // 读取每个技能的属性
                for (int j = 0; j < n; j++) {
                    in.nextToken();
                    kill[j] = (int) in.nval;  // 伤害值
                    in.nextToken();
                    blood[j] = (int) in.nval; // 血量阈值
                }
                
                // 求解并输出结果
                int ans = f(n, 0, m);
                out.println(ans == Integer.MAX_VALUE ? -1 : ans);
            }
        }
        
        out.flush();
        br.close();
        out.close();
    }
    
    public static int f(int n, int i, int r) {
        // 基础情况1：怪物已死亡
        if (r <= 0) {
            return i; // 返回已使用的技能数
        }
        
        // 基础情况2：技能用完但怪物还活着
        if (i == n) {
            return Integer.MAX_VALUE; // 无效方案
        }
        
        // 尝试所有可能的技能排列
        int ans = Integer.MAX_VALUE;
        for (int j = i; j < n; j++) {
            // 将第j个技能交换到第i个位置
            swap(i, j);
            
            // 计算使用当前技能后的伤害
            // 如果怪物血量 > 阈值，造成普通伤害；否则造成双倍伤害
            int damage = r > blood[i] ? kill[i] : kill[i] * 2;
            
            // 递归计算后续最优解
            ans = Math.min(ans, f(n, i + 1, r - damage));
            
            // 回溯：恢复原状态
            swap(i, j);
        }
        
        return ans;
    }
    
    public static void swap(int i, int j) {
        int tmp = kill[i];
        kill[i] = kill[j];
        kill[j] = tmp;
        
        tmp = blood[i];
        blood[i] = blood[j];
        blood[j] = tmp;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

从括号匹配到字符串解码-递归思想的巧妙应用

Sat, 15 Nov 2025 20:58:02 +0000

解题思路

这是一个典型的递归问题。关键在于处理嵌套的括号结构：

遇到字母：直接加入结果
遇到数字：累积重复次数
遇到 [：递归处理括号内的子串
遇到 ]：当前层递归结束，返回结果

使用全局变量 where 记录当前处理位置，让上层递归知道从哪继续处理。

完整代码实现

public class Solution {
    // 全局变量，记录当前处理到的位置
    public static int where;
   
    public static String decodeString(String str) {
        where = 0;
        return f(str.toCharArray(), 0);
    }
    
    public static String f(char[] s, int i) {
        StringBuilder path = new StringBuilder();
        int cnt = 0;  // 记录重复次数
        
        // 遍历字符串，直到遇到 ']' 或结束
        while (i < s.length && s[i] != ']') {
            if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z')) {
                // 情况1：遇到字母，直接追加
                path.append(s[i++]);
                
            } else if (s[i] >= '0' && s[i] <= '9') {
                // 情况2：遇到数字，累积计算重复次数（可能是多位数）
                cnt = cnt * 10 + s[i++] - '0';
                
            } else {
                // 情况3：遇到 '['，需要递归处理括号内的内容
                // 递归调用 f，从 i+1 位置开始（跳过当前的'['）
                String subResult = f(s, i + 1);
                
                // 将递归结果重复 cnt 次，追加到当前结果
                path.append(get(cnt, subResult));
                
                // 更新 i 到递归结束的位置（跳过对应的']'）
                i = where + 1;
                
                // 重置重复次数
                cnt = 0;
            }
        }
        
        // 更新全局位置变量，记录当前处理到哪里
        // 如果遇到']'，where指向']'；否则指向字符串末尾
        where = i;
        
        return path.toString();
    }
    
    public static String get(int cnt, String str) {
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < cnt; i++) {
            builder.append(str);
        }
        return builder.toString();
    }
  
}

如果觉得有帮助，欢迎点赞、关注、转发~

全排列II-一个HashSet搞定去重难题

Fri, 14 Nov 2025 21:11:12 +0000

求解思路

这题如果直接套用普通全排列的模板，会得到 6 个结果，其中有重复！因此，难点在于去重。

这里采用位置固定法结合回溯来生成排列：

从左到右依次确定每个位置，对于位置 i，尝试把 [i, n) 范围内的每个数字交换到位置 i，然后递归处理位置 i+1。

去重的关键在于：用一个 HashSet 记录当前位置已经尝试过的数字，如果某个值已经被尝试过了就直接跳过，这样就能从源头避免重复排列的产生

完整代码

public static List<List<Integer>> permuteUnique(int[] nums){
        List<List<Integer>> ans = new ArrayList<>();
        f(nums,0,ans);
        return ans;
    }

    public static void f(int[] nums,int i,List<List<Integer>> ans){
        if(i==nums.length){
            List<Integer> cur = new ArrayList<>();
            for (int num:nums){
                cur.add(num);
            }
            ans.add(cur);
        }else{
            HashSet<Integer> set = new HashSet<>();
            for (int j = i; j < nums.length; j++) {
                // 关键判断：这个值在位置i没试过，才去尝试
                if (!set.contains(nums[j])) {
                    set.add(nums[j]);       // 标记已尝试
                    swap(nums, i, j);       // 做选择
                    f(nums, i + 1, ans);    // 递归
                    swap(nums, i, j);       // 撤销选择
                }
            }
        }
    }

    public static void swap(int[] nums,int i,int j){
        int tmp = nums[i];
        nums[i]=nums[j];
        nums[j]=tmp;
    }

如果觉得有帮助，欢迎点赞、关注、转发~

一文彻底掌握全排列算法

Thu, 13 Nov 2025 22:52:24 +0000

求解思路

从左到右按照位置顺序逐个固定每个位置上的元素,对于当前位置 i,通过交换操作依次尝试将后续区间 [i, n-1] 中的每个元素放到位置 i,然后递归地处理位置 i+1 及其后续位置,当所有位置都确定后就得到一个完整的排列,而每次递归返回后通过再次交换恢复数组到进入递归前的状态,这样就能继续尝试为当前位置选择其他元素。

完整代码实现

public class Solution {
    
    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        f(nums, 0, ans);
        return ans;
    }
    
    public static void f(int[] nums, int i, List<List<Integer>> ans) {
        // 递归终止条件:所有位置都已固定
        if (i == nums.length) {
            List<Integer> cur = new ArrayList<>();
            for (int num : nums) {
                cur.add(num);
            }
            ans.add(cur);
        } else {
            // 尝试将 [i, n-1] 范围内的每个元素放到位置 i
            for (int j = i; j < nums.length; j++) {
                swap(nums, i, j);        // 选择:将 nums[j] 放到位置 i
                f(nums, i + 1, ans);     // 递归:处理后续位置
                swap(nums, i, j);        // 回溯:恢复原状,尝试其他选择
            }
        }
    }
    
    public static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

如果觉得有帮助，欢迎点赞、关注、转发~

一文吃透字符串子序列-递归、回溯、去重全掌握

Tue, 11 Nov 2025 21:23:19 +0000

这是一个经典的递归问题，今天来看看2种不同的实现方式。

求解思路

对于字符串中的每个字符，都会面临“要这个字符”和“不要这个字符”两个选择。通过递归遍历所有字符，就能生成所有可能的子序列。

方法1

public static String[] generatePermutation(String str) {
        char[] s = str.toCharArray();
        HashSet<String> set = new HashSet<>();
        f1(s, 0, new StringBuilder(), set);

        f1(s,0,new StringBuilder(),set);
        // 转换为列表并排序
        List<String> list = new ArrayList<>(set);
        Collections.sort(list);  // 字典序排序

        return list.toArray(new String[0]);
    }

    // s[i...]：从位置i开始处理
    // path：当前已构建的路径
    // set：收集所有结果并去重
    public static void f1(char[] s, int i, StringBuilder path, HashSet<String> set) {
        if (i == s.length) {
            // 到达末尾，将当前路径加入结果集
            set.add(path.toString());
        } else {
            // 选择1：要当前字符
            path.append(s[i]);
            f1(s, i + 1, path, set);
            path.deleteCharAt(path.length() - 1); // 恢复现场

            // 选择2：不要当前字符
            f1(s, i + 1, path, set);
        }
    }

方法2

public static String[] generatePermutation(String str) {
        char[] s = str.toCharArray();
        HashSet<String> set = new HashSet<>();
        f2(s, 0, new char[s.length], 0, set);

        // 转换为列表并排序
        List<String> list = new ArrayList<>(set);
        Collections.sort(list);  // 字典序排序

        return list.toArray(new String[0]);
    }

    // s[i...]：从位置i开始处理
    // path：固定大小的字符数组
    // size：path中已填入的字符个数
    // set：收集结果并去重
    public static void f2(char[] s, int i, char[] path, int size, HashSet<String> set) {
        if (i == s.length) {
            // 只使用path的前size个字符
            set.add(String.valueOf(path, 0, size));
        } else {
            // 选择1：要当前字符
            path[size] = s[i];
            f2(s, i + 1, path, size + 1, set);

            // 选择2：不要当前字符
            f2(s, i + 1, path, size, set);
        }
    }

如果觉得有帮助，欢迎点赞、关注、转发~