华为机试：学生方阵

最新推荐文章于 2025-02-13 08:17:09 发布

小朱小朱绝不服输

最新推荐文章于 2025-02-13 08:17:09 发布

阅读量3.2k

点赞数 4

分类专栏：华为机试文章标签：算法 java 华为机试 DP 模拟

本文链接：https://blog.youkuaiyun.com/weixin_44052055/article/details/125881141

版权

华为机试专栏收录该内容

69 篇文章

订阅专栏

这篇博客介绍了如何解决一个学生方阵排列的问题，目标是找到矩形方阵中最大位置相连的男生数量。文章提供了两种解法，一种是动态规划，分为四个方向分别进行；另一种是模拟法，分别讨论四种情况。每种方法都给出了详细的思路分析和参考代码，并邀请读者在评论区分享更简洁的算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【编程题目 |200分】学生方阵【2022 Q2 考试题】

题目描述

学校组织活动，将学生排成一个矩形方阵。
请在矩形方阵中找到最大的位置相连的男生数量。
这个相连位置在一个直线上，方向可以是水平的，垂直的，成对角线的或者呈反对角线的。
注：学生个数不会超过10000

输入描述

输入的第一行为矩阵的行数和列数，接下来的n行为矩阵元素，元素间用”,”分隔。

输出描述

输出一个整数，表示矩阵中最长的位置相连的男生个数。

示例

输入

3,4
F,M,M,F
F,M,M,F
F,F,F,M

输出

输入

1,2
M,M

输出

输入

2,1
M
F

输出

思路分析

方法一：动态规划

这道题看到方阵，下一个格子跟上一个格子有关系，横着、竖着、对角线、反对角线，可以想到动态规划的解法。

不过需要注意的是，四种情况要分开考虑，分别进行动态规划：

初始化第一行和第一列，往右下角找，就可以统计横着，竖着，对角线的最大值。
初始化第一行，最后一列，往左下角找，就可以统计反对角线的最大值。

如果整体动态规划，则横着的会影响竖着的，比如

3,4
F,M,M,F
F,M,M,F
F,F,F,F

如果直接整体动态规划，会受到干扰，会出现重复加的情况

dp[i][j] = Math.max(dp[i - 1][j], Math.max(dp[i][j - 1), dp[i - 1][j - 1]) + 1;

所以需要分开四个方向分别进行动态规划，最后再计算四个方向的最大值。

还有一点需要注意的是，在初始化数组的时候，如果对第一行，第一列，或者最后一列，遇到"M"，初始化为1时，当只有一行或一列的情况，则不会统计，因此需要对特殊情况，一行或一列的单独进行处理。

方法二：模拟

分别讨论这四种情况下的最长数量。

参考代码

方法一：动态规划

import java.util.Scanner;
public class studentFangZhen {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] str1 = in.nextLine().split(",");
        int m = Integer.parseInt(str1[0]);
        int n = Integer.parseInt(str1[1]);
        String[][] s = new String[m][n];
        for (int i = 0; i < m; i++) {
            String[] s1 = in.nextLine().split(",");
            for (int j = 0; j < n; j++) {
                s[i][j] = s1[j];
            }
        }
        int[][] dp1 = new int[m][n];  // 从左往右
        int[][] dp2 = new int[m][n];  // 从上往下
        int[][] dp3 = new int[m][n];  // 对角线
        int[][] dp4 = new int[m][n];  // 反对角线
        // 特例，只有一行或只有一列，不能给每一个等于M的初始化为1，还要考虑前一个的情况
        int ans = 0;
        if (m == 1) {
            if (s[0][0].equals("M")) {
                dp1[0][0] = 1;
            }
            for (int j = 1; j < n; j++) {
                if (s[0][j - 1].equals("M")) {
                    if (s[0][j].equals("M")) {
                        dp1[0][j] = dp1[0][j - 1] + 1;
                    }
                } else {
                    if (s[0][j].equals("M")){
                        dp1[0][j] = 1;
                    }
                }
            }
            for (int j = 0; j < n; j++) {
                ans = Math.max(ans, dp1[0][j]);
            }
            System.out.println(ans);
            return;
        }
        if (n == 1) {
            if (s[0][0].equals("M")) {
                dp2[0][0] = 1;
            }
            for (int i = 1; i < m; i++) {
                if (s[i - 1][0].equals("M")) {
                    if (s[i][0].equals("M")) {
                        dp2[i][0] = dp2[i - 1][0] + 1;
                    }
                } else {
                    if (s[i][0].equals("M")) {
                        dp2[i][0] = 1;
                    }
                }
            }
            for (int i = 0; i < m; i++) {
                ans = Math.max(ans, dp2[i][0]);
            }
            System.out.println(ans);
            return;
        }
        // 初始化dp1, dp2, dp3, dp4数组
        for (int i = 0; i < m; i++) {
            if (s[i][0].equals("M")) {
                dp1[i][0] = 1;
                dp2[i][0] = 1;
                dp3[i][0] = 1;
            }
        }
        for (int j = 0; j < n; j++) {
            if (s[0][j].equals("M")) {
                dp1[0][j] = 1;
                dp2[0][j] = 1;
                dp3[0][j] = 1;
                dp4[0][j] = 1;
            }
        }
        // 初始化dp4数组
        for (int i = 0; i < m; i++) {
            if (s[i][n - 1].equals("M")) {
                dp4[i][n - 1] = 1;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (s[i][j].equals("M")) {
                    if (s[i][j - 1].equals("M")) { // 从左往右
                        dp1[i][j] = dp1[i][j - 1] + 1;
                    }
                    if (s[i - 1][j].equals("M")) {  // 从上往下
                        dp2[i][j] = dp2[i - 1][j] + 1;
                    }
                    if (s[i - 1][j - 1].equals("M")) { // 对角线
                        dp3[i][j] = dp3[i - 1][j - 1] + 1;
                    }
                }
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = n - 2; j >= 0; j--) {
                if (s[i][j].equals("M")) {
                    if (s[i - 1][j + 1].equals("M")) { // 反对角线
                        dp4[i][j] = dp4[i - 1][j + 1] + 1;
                    }
                }
            }
        }
        for (int i = 0; i < m; i++) {  // 取四个数组中的最大值
            for (int j = 0; j < n; j++) {
                ans = Math.max(ans, Math.max(dp1[i][j], Math.max(dp2[i][j], Math.max(dp3[i][j], dp4[i][j]))));
            }
        }
        System.out.println(ans);
    }
}

这样写下来比较复杂，欢迎在评论区讨论以及留下更简单的算法。

方法二：模拟

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class StudentFangZhen2 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String[] str1 = in.nextLine().split(",");
        int m = Integer.parseInt(str1[0]);
        int n = Integer.parseInt(str1[1]);
        String[][] s = new String[m][n];
        for (int i = 0; i < m; i++) {
            String[] s1 = in.nextLine().split(",");
            for (int j = 0; j < n; j++) {
                s[i][j] = s1[j];
            }
        }
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (s[i][j].equals("M")) {
                    getResult(s, i, j, list);
                }
            }
        }
        Collections.sort(list);
        System.out.println(list.get(list.size() - 1));
    }
    public static void getResult(String[][] s, int i, int j, List<Integer> list) {
        int len = 1;
        int a = 0, b = 0;
        int m = s.length, n = s[0].length;
        if (j < n) {  // 从左往右
            a = i;
            b = j;
            while (b < n - 1 && s[a][++b].equals("M")) {
                len++;
            }
            list.add(len);
            len = 1;
        }
        if (i < m) {  // 从上往下
            a = i;
            b = j;
            while (a < m - 1 && s[++a][b].equals("M")) {
                len++;
            }
            list.add(len);
            len = 1;
        }
        if (i < m && j < n) {  // 对角线
            a = i;
            b = j;
            while ((a < m - 1 && b < n - 1) && s[++a][++b].equals("M")) {
                len++;
            }
            list.add(len);
            len = 1;
        }
        if (i >= 0 && j < n) {  // 从左往右
            a = i;
            b = j;
            while (( a > 0 && b < n - 1) && s[--a][++b].equals("M")) {
                len++;
            }
            list.add(len);
        }
    }
}