华为OD 2024笔试机试 - 找单词 (Java/C++/Python C卷D卷真题算法)

华为OD机试（C卷+D卷）2024真题目录(Java & c++ & python)

题目描述

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

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

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

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

输入描述

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

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

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

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

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

输出描述

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

用例

输入

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

输出

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

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

解题思路

C++/Java/Python代码如下

C++参考代码

#include <iostream>
#include <vector>
#include <string>

using namespace std;

bool dfs(vector<vector<char>>& board, string& word, int idx, int x, int y, vector<vector<bool>>& visited, vector<int>& path) {
    if (idx == word.length()) return true;
    int n = board.size();
    if (x < 0 || x >= n || y < 0 || y >= n || visited[x][y] || board[x][y] != word[idx]) return false;

    visited[x][y] = true;
    path.push_back(x);
    path.push_back(y);

    static int dx[4] = {0, 1, 0, -1};
    static int dy[4] = {1, 0, -1, 0};

    for (int dir = 0; dir < 4; ++dir) {
        if (dfs(board, word, idx + 1, x + dx[dir], y + dy[dir], visited, path)) return true;
    }

    visited[x][y] = false;
    path.pop_back();
    path.pop_back();
    return false;
}

string findWord(vector<vector<char>>& board, string& word) {
    int n = board.size();
    vector<vector<bool>> visited(n, vector<bool>(n, false));
    vector<int> path;

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (dfs(board, word, 0, i, j, visited, path)) {
                string result;
                for (int k = 0; k < path.size(); ++k) {
                    result += to_string(path[k]);
                    if (k != path.size() - 1) result += ",";
                }
                return result;
            }
        }
    }
    return "N";
}

int main() {
    int n;
    cin >> n;
    cin.ignore();
    vector<vector<char>> board(n, vector<char>(n));
    for (int i = 0; i < n; ++i) {
        string line;
        getline(cin, line);
        int idx = 0;
        for (int j = 0; j < n; ++j) {
            board[i][j] = line[idx];
            idx += 2; // 跳过逗号
        }
    }

    string word;
    getline(cin, word);
    cout << findWord(board, word) << endl;
    return 0;
}

Java参考代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        char[][] board = new char[n][n];
        for (int i = 0; i < n; i++) {
            String[] line = sc.nextLine().split(",");
            for (int j = 0; j < n; j++) {
                board[i][j] = line[j].charAt(0);
            }
        }
        String word = sc.nextLine();
        System.out.println(findWord(board, word));
    }

    public static String findWord(char[][] board, String word) {
        int n = board.length;
        boolean[][] visited = new boolean[n][n];
        StringBuilder path = new StringBuilder();

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (dfs(board, word, 0, i, j, visited, path)) {
                    return path.toString();
                }
            }
        }
        return "N";
    }

    private static boolean dfs(char[][] board, String word, int idx, int x, int y, boolean[][] visited, StringBuilder path) {
        if (idx == word.length()) return true;
        int n = board.length;
        if (x < 0 || x >= n || y < 0 || y >= n || visited[x][y] || board[x][y] != word.charAt(idx)) return false;

        visited[x][y] = true;
        path.append(x).append(",").append(y).append(",");
        int[] dx = {0, 1, 0, -1};
        int[] dy = {1, 0, -1, 0};

        for (int dir = 0; dir < 4; dir++) {
            if (dfs(board, word, idx + 1, x + dx[dir], y + dy[dir], visited, path)) return true;
        }

        visited[x][y] = false;
        path.setLength(path.length() - 4);
        return false;
    }
}

Python参考代码

def dfs(board, word, idx, x, y, visited, path):
    if idx == len(word):
        return True
    n = len(board)
    if x < 0 or x >= n or y < 0 or y >= n or visited[x][y] or board[x][y] != word[idx]:
        return False

    visited[x][y] = True
    path.append((x, y))

    directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
    for dx, dy in directions:
        if dfs(board, word, idx + 1, x + dx, y + dy, visited, path):
            return True

    visited[x][y] = False
    path.pop()
    return False

def find_word(board, word):
    n = len(board)
    visited = [[False] * n for _ in range(n)]
    path = []

    for i in range(n):
        for j in range(n):
            if dfs(board, word, 0, i, j, visited, path):
                return ",".join(f"{x},{y}" for x, y in path)
    return "N"

if __name__ == "__main__":
    import sys
    input = sys.stdin.read
    data = input().split('\n')
    n = int(data[0])
    board = [list(map(str, line.split(','))) for line in data[1:n+1]]
    word = data[n+1].strip()
    print(find_word(board, word))