华为OD机试 - 找单词 - 深度优先搜索DFS（Java 2024 E卷 100分）

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（E卷+D卷+A卷+B卷+C卷）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

给一个字符串和一个二维字符数组Q，如果该字符串存在于该数组中，则按字符串的字符顺序输出字符串每个字符所在单元格的位置标号字符串，如果找不到则返回字符串“N”。

需要按字符串的字符组顺序 顺序搜索，且搜索到的位置必须是相邻单元格，其中“相邻单元格”是指那些水平方向或垂直方向相邻的单元格。

同一个单元格内的字母不允许被重复使用。

假定在数组中最多只存在一个可能的匹配。

二、输入描述

第1行输入一个数字N指示二维数组在后续输入所占的行数。

第2行到第N+1行输入为一个二维大写字符数组，每行字符用半角分割。

第N+2行为待查找的字符串，由大写字母组成。

二维数组的大小为N*N，0 < N <= 100。

单词长度K，0 < K <= 1000。

三、输出描述

输出一个位置下标字符串，拼接格式为：第1个字符行下标”,“第1个字符列下标”,“第2个字符行下标”,“第2个字符列下标…“,“第N个字符行下标”。

四、测试用例

测试用例1：

1、输入

4
A,C,C,F
C,D,E,D
B,E,S,S
F,E,C,A
ACCESS

2、输出

0,0,0,1,0,2,1,2,2,2,2,3

3、说明

ACCESS分别对应二维数组的[0,0][0,1][0,2][1,2][2,2][2,3]下标位置。

测试用例2：

1、输入

5
C,A,T,S,Z
B,A,B,D,X
D,O,G,S,Y
H,E,L,L,O
W,O,R,L,D
HELLO

2、输出

3,0,3,1,3,2,3,3,3,4

3、说明

字符串 “HELLO” 可以通过在二维数组中以下路径找到：

H -> E -> L -> L -> O

对应的位置下标是 [3,0] -> [3,1] -> [3,2] -> [3,3] -> [3,4]，输出为 “3,0,3,1,3,2,3,3,3,4”。

该测试用例验证了算法可以正确处理位于单行或单列中的字符串。

五、解题思路

1、问题分析

我们需要在一个二维数组中寻找一个给定的字符串，字符之间的连接必须是相邻的。典型的搜索问题，特别是路径搜索问题，可以通过 深度优先搜索（DFS） 来解决。DFS 可以探索所有可能的路径，直到找到匹配的路径或者确定没有可行路径。

2、基本思路

DFS递归搜索：

从当前字符开始，向四个相邻方向（上、下、左、右）扩展，继续匹配字符串的下一个字符。

使用一个访问标记数组 visited，以防止重复使用同一个字符。

如果匹配完成整个字符串，则记录并返回字符路径的位置。

如果当前路径不正确，进行回溯（撤销访问标记，移除路径中的当前位置），尝试其他路径。

3、具体步骤：

1. 输入处理：
   • 读取二维字符数组和要查找的字符串。
   • 使用 Scanner 读取输入，处理字符数组和字符串。
2. 开始搜索：
   • 对于数组中的每一个位置，检查其是否是字符串的第一个字符。
   • 如果是，则调用 DFS 搜索该字符的路径。
3. DFS搜索：
   • 检查当前字符是否匹配，并且在数组边界内。
   • 记录当前位置，并向四个方向扩展搜索。
   • 递归调用 DFS，尝试匹配下一个字符。
   • 如果搜索到最后一个字符，返回成功并记录路径。
   • 如果搜索失败，进行回溯，撤销访问标记和路径。
4. 结果输出：
   • 如果找到匹配路径，输出路径字符串。
   • 如果未找到，输出 “N”。

六、Java算法源码

public class OdTest01 {
    private static int[] rowOffsets = {-1, 1, 0, 0}; // 上下左右的偏移量
    private static int[] colOffsets = {0, 0, -1, 1};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        scanner.nextLine(); // 消耗换行符

        char[][] board = new char[N][N];
        for (int i = 0; i < N; i++) {
            String[] line = scanner.nextLine().split(",");
            for (int j = 0; j < N; j++) {
                board[i][j] = line[j].charAt(0);
            }
        }

        String word = scanner.nextLine();
        scanner.close();

        // 尝试在每个位置开始寻找匹配
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (board[i][j] == word.charAt(0)) {
                    boolean[][] visited = new boolean[N][N];
                    StringBuilder path = new StringBuilder();
                    if (dfs(board, visited, i, j, word, 0, path)) {
                        System.out.println(path.toString());
                        return;
                    }
                }
            }
        }

        System.out.println("N");
    }

    // 深度优先搜索(DFS)方法
    private static boolean dfs(char[][] board, boolean[][] visited, int row, int col, String word, int index, StringBuilder path) {
        if (index == word.length()) {
            return true; // 已经匹配完所有字符
        }

        if (row < 0 || row >= board.length || col < 0 || col >= board[0].length || visited[row][col] || board[row][col] != word.charAt(index)) {
            return false; // 超出边界或字符不匹配或已经访问过
        }

        // 标记当前位置已访问，并添加到路径
        visited[row][col] = true;
        path.append(row).append(",").append(col).append(",");

        // 继续向四个方向搜索
        for (int direction = 0; direction < 4; direction++) {
            int newRow = row + rowOffsets[direction];
            int newCol = col + colOffsets[direction];
            if (dfs(board, visited, newRow, newCol, word, index + 1, path)) {
                return true;
            }
        }

        // 回溯，如果没有找到正确路径，撤销访问标记并移除最后的路径
        visited[row][col] = false;
        path.setLength(path.length() - 4); // 移除最后添加的路径 "row,col,"
        return false;
    }
}

七、效果展示

1、输入

3
A,A,A
B,B,B
C,C,C
ABC

2、输出

0,0,1,0,2,0

3、说明

字符串 “ABC” 可以通过在二维数组中以下路径找到：

A -> B -> C

对应的位置下标是 [0,0] -> [1,0] -> [2,0]，输出为 “0,0,1,0,2,0”。

该测试用例验证了在二维数组中有多个相同字符时，算法能正确选择合适的路径，而不重复使用同一个字符。

🏆下一篇：华为OD机试 - 简易内存池 - 逻辑分析（Java 2024 D卷 200分）

🏆本文收录于，华为OD机试（JAVA）真题（E卷+D卷+A卷+B卷+C卷）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。