1
#include <stdio.h>
2
#include <stdlib.h>
3

4
#define MAXN 105
5
int n;
6
int grid[MAXN][MAXN];     // 存储地图，1表示障碍，0表示落脚点
7
int visited[MAXN][MAXN];  // 标记数组，记录0是否被访问过
8
int max_ans = 0;          // 记录最大跳跃距离
9

10
// 方向数组：上，下，左，右
11
int dx[4] = {-1, 1, 0, 0};
12
int dy[4] = {0, 0, -1, 1};
13

14
// 检查坐标是否在地图范围内
15
int isValid(int x, int y) {
16
    return x >= 0 && x < n && y >= 0 && y < n;
17
}
18

19
/**
20
 * 深度优先搜索
21
 * @param x 当前行坐标
22
 * @param y 当前列坐标
23
 * @param current_dist 从起点到当前的累计距离
24
 */
25
void dfs(int x, int y, int current_dist) {
26
    // 更新最大值
27
    if (current_dist > max_ans) {
28
        max_ans = current_dist;
29
    }
30

31
    // 尝试四个方向
32
    for (int i = 0; i < 4; i++) {
33
        int nx = x + dx[i];
34
        int ny = y + dy[i];
35

36
        // 规则1: 必须紧邻着 '1' 才能起跳
37
        // 如果越界或者紧邻的不是1，说明这个方向不能跳
38
        if (!isValid(nx, ny) || grid[nx][ny] != 1) {
39
            continue;
40
        }
41

42
        // 规则2: 连续越过所有的 '1'
43
        int count_ones = 0;
44
        while (isValid(nx, ny) && grid[nx][ny] == 1) {
45
            nx += dx[i];
46
            ny += dy[i];
47
            count_ones++;
48
        }
49

50
        // 规则3: 落地检查
51
        // 此时 nx, ny 指向了跳过一串1之后的位置
52
        // 该位置必须在界内，必须是 '0'，且必须未被访问过
53
        if (isValid(nx, ny) && grid[nx][ny] == 0 && !visited[nx][ny]) {
54
            // 标记访问
55
            visited[nx][ny] = 1;
56

57
            // 距离计算：跳过的1的个数 + 1
58
            int step_dist = count_ones + 1;
59

60
            // 递归搜索
61
            dfs(nx, ny, current_dist + step_dist);
62

63
            // 回溯：取消标记，以便其他路径可以使用该点
64
            visited[nx][ny] = 0;
65
        }
66
    }
67
}
68

69
int main() {
70
    int start_x, start_y;
71

72
    // 输入处理
73
    if (scanf("%d %d %d", &n, &start_x, &start_y) != 3) {
74
        return 0;
75
    }
76

77
    // 题目输入坐标是1-based，转换为C语言的0-based
78
    start_x--;
79
    start_y--;
80

81
    for (int i = 0; i < n; i++) {
82
        for (int j = 0; j < n; j++) {
83
            scanf("%d", &grid[i][j]);
84
            visited[i][j] = 0; // 初始化访问数组
85
        }
86
    }
87

88
    // 起点处理：起点算作已访问，不能再次到达
89
    visited[start_x][start_y] = 1;
90

91
    // 开始搜索，初始距离为0
92
    dfs(start_x, start_y, 0);
93

94
    // 输出结果
95
    printf("%d\n", max_ans);
96
    system("pause");
97
    return 0;
98
}

1
#include <stdio.h>
2

3
#define MAXN 105
4

5
int n, grid[MAXN][MAXN], visited[MAXN][MAXN];
6
int dx[] = {-1, 1, 0, 0}; // 也可以省略大小，编译器自动推断
7
int dy[] = {0, 0, -1, 1};
8

9
// 优化：函数返回 int，表示“从当前点出发能得到的最大后续距离”
10
int dfs(int x, int y) {
11
    int local_max = 0; // 记录从这一步出发，四个方向里最好的那个结果
12

13
    for (int i = 0; i < 4; i++) {
14
        int nx = x + dx[i], ny = y + dy[i];
15
        int steps = 0; // 记录越过的1的个数
16

17
        // 1. 起跳检查：利用 (unsigned) 技巧合并边界判断
18
        // 必须不越界 且 下一格是 1
19
        if ((unsigned)nx < n && (unsigned)ny < n && grid[nx][ny] == 1) {
20

21
            // 2. 飞行过程：只要是 1 就一直飞
22
            while ((unsigned)nx < n && (unsigned)ny < n && grid[nx][ny] == 1) {
23
                nx += dx[i];
24
                ny += dy[i];
25
                steps++;
26
            }
27

28
            // 3. 落地检查：必须不越界 且 是0 且 未访问
29
            if ((unsigned)nx < n && (unsigned)ny < n && !grid[nx][ny] && !visited[nx][ny]) {
30
                visited[nx][ny] = 1;
31

32
                // 核心逻辑：本次跳跃距离(steps+1) + 后续能跳的最远距离
33
                int val = (steps + 1) + dfs(nx, ny);
34

35
                if (val > local_max) local_max = val; // 更新当前点的最优解
36

37
                visited[nx][ny] = 0; // 回溯
38
            }
39
        }
40
    }
41
    return local_max;
42
}
43

44
int main() {
45
    int sx, sy;
46
    if (scanf("%d %d %d", &n, &sx, &sy) != 3) return 0;
47

48
    for (int i = 0; i < n; i++)
49
        for (int j = 0; j < n; j++)
50
            scanf("%d", &grid[i][j]);
51

52
    visited[--sx][--sy] = 1; // 坐标 -1 并标记起点
53

54
    printf("%d\n", dfs(sx, sy)); // 直接打印返回值
55
    return 0;
56
}