校招算法笔面试 | 校招笔面试真题-字符迷阵

题目

题目链接

解题思路

1. 这是一个字符迷阵搜索问题，需要在矩阵中寻找特定单词
2. 搜索规则：
   • 可以从任意位置开始
   • 只能向右、向下或右下45度方向延伸
   • 合法方案可以重叠
3. 解题步骤：
   • 遍历矩阵中每个字符作为起点
   • 对于每个起点，检查三个可能的方向
   • 统计所有合法方案的数量

---

代码

#include <iostream>
#include <string>
using namespace std;

int n, m;

int search(const string maze[], const string& word, int x, int y) {
    int len = word.length();
    int flag1 = 1, flag2 = 1, flag3 = 1;
    
    // 检查三个方向：右、下、右下
    for(int i = 0; i < len; i++) {
        // 向右检查
        if(y + i >= m || word[i] != maze[x][y+i]) {
            flag1 = 0;
        }
        // 向下检查
        if(x + i >= n || word[i] != maze[x+i][y]) {
            flag2 = 0;
        }
        // 右下对角线检查
        if(x + i >= n || y + i >= m || word[i] != maze[x+i][y+i]) {
            flag3 = 0;
        }
    }
    return flag1 + flag2 + flag3;
}

int main() {
    int T;
    cin >> T;
    while(T--) {
        cin >> n >> m;
        string maze[105];
        for(int i = 0; i < n; i++) {
            cin >> maze[i];
        }
        string word;
        cin >> word;
        
        int result = 0;
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(word[0] == maze[i][j]) {
                    result += search(maze, word, i, j);
                }
            }
        }
        cout << result << endl;
    }
    return 0;
}

import java.util.*;

public class Main {
    static int n, m;
    
    static int search(String[] maze, String word, int x, int y) {
        int len = word.length();
        int flag1 = 1, flag2 = 1, flag3 = 1;
        
        for(int i = 0; i < len; i++) {
            // 向右检查
            if(y + i >= m || word.charAt(i) != maze[x].charAt(y+i)) {
                flag1 = 0;
            }
            // 向下检查
            if(x + i >= n || word.charAt(i) != maze[x+i].charAt(y)) {
                flag2 = 0;
            }
            // 右下对角线检查
            if(x + i >= n || y + i >= m || word.charAt(i) != maze[x+i].charAt(y+i)) {
                flag3 = 0;
            }
        }
        return flag1 + flag2 + flag3;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while(T-- > 0) {
            n = sc.nextInt();
            m = sc.nextInt();
            String[] maze = new String[105];
            for(int i = 0; i < n; i++) {
                maze[i] = sc.next();
            }
            String word = sc.next();
            
            int result = 0;
            for(int i = 0; i < n; i++) {
                for(int j = 0; j < m; j++) {
                    if(word.charAt(0) == maze[i].charAt(j)) {
                        result += search(maze, word, i, j);
                    }
                }
            }
            System.out.println(result);
        }
    }
}

def search(maze, word, x, y, n, m):
    length = len(word)
    flag1 = flag2 = flag3 = 1
    
    for i in range(length):
        # 向右检查
        if y + i >= m or word[i] != maze[x][y+i]:
            flag1 = 0
        # 向下检查
        if x + i >= n or word[i] != maze[x+i][y]:
            flag2 = 0
        # 右下对角线检查
        if x + i >= n or y + i >= m or word[i] != maze[x+i][y+i]:
            flag3 = 0
            
    return flag1 + flag2 + flag3

T = int(input())
for _ in range(T):
    n, m = map(int, input().split())
    maze = [input() for _ in range(n)]
    word = input()
    
    result = 0
    for i in range(n):
        for j in range(m):
            if word[0] == maze[i][j]:
                result += search(maze, word, i, j, n, m)
                
    print(result)

---

算法及复杂度

• 算法：矩阵遍历 + 字符串匹配
• 时间复杂度：$\mathcal{O}(T\cdot n\cdot m\cdot L)$ - $T$ 为测试用例数，$n$ 和 $m$ 为矩阵维度，$L$ 为单词长度
• 空间复杂度：$\mathcal{O}(n\cdot m)$ - 需要存储字符矩阵