华为OD-机试
B 卷
100 分题 1：支持优先级的队列
实现一个支持优先级的队列，高优先级先出队列，同优先级时先进先出。
如果两个输入数据和优先级都相同，则后一个数据不入队列被丢弃。
队列存储的数据内容是一个整数。
输入描述：一组待存入队列的数据（包含内容和优先级）。
输出描述：队列的数据内容（优先级信息输出时不再体现）。
补充说明：不用考虑数据不合法的情况，测试数据不超过100个。
示例1
输入：(10,1),(20,1),(30,2),(40,3)输出：40,30,10,20
说明:
输入样例中，向队列写入了4个数据，每个数据由数据内容和优先级组成。输入和输出内容都不含空格。
数据40的优先级最高，所以最先输出，其次是30：10和20优先级相同，所以按输入顺序输出
示例2
输入：(10,1),(10,1),(30,2),(40,3)输出：40,30,10
说明：数据40的优先级最高，所以最先输出，其次是30;两个10和10构成重复数据，被丢弃一个。
/**
* 优先队列节点定义
*/
class PriorityQueueItem {
int data;
int priority;
public PriorityQueueItem(int data, int priority) {
this.data = data;
this.priority = priority;
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
List<PriorityQueueItem> queue = new ArrayList<>();
/*
获取并处理输入：获取一整行字符串并拆分提取数据
*/
while (in.hasNext()) {
String[] element = in.next().split(",");
for (int i = 0; i < element.length; i += 2) {
int data = Integer.parseInt(element[i].substring(1));
int priority = Integer.parseInt(element[i + 1].substring(0, element[1].length() - 1));
addToQueue(queue, data, priority);
}
}
/*
打印
*/
for (int i = 0; i < queue.size(); i++) {
if (i == queue.size() - 1) System.out.print(queue.get(i).data);
else System.out.print(queue.get(i).data + ",");
}
}
private static void addToQueue(List<PriorityQueueItem> queue, int data, int priority) {
// 排除重复元素
for (PriorityQueueItem item : queue) {
if (item.data == data && item.priority == priority) return;
}
// 遍历整个优先队列，如果优先级小于准备插入的节点，就将节点插入到当前位置
// 为了实现相同优先级先进入的先插入，则只能是 >
// 这里并不适合改成二分查找，因为并不是找一个确定的位置，而是找第一个优先级更小的位置
for (int i = 0; i < queue.size(); i++) {
if (priority > queue.get(i).priority) {
queue.add(i, new PriorityQueueItem(data, priority));
return;
}
}
queue.add(new PriorityQueueItem(data, priority));
}
}
100 分题 2：计算最大乘积
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
String[] arr = in.nextLine().split(",");
int max = 0;
/*
两两检查
*/
for (int i = 0; i < arr.length; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (!check(arr[i], arr[j])) max = Math.max(max, arr[i].length() * arr[j].length());
}
}
System.out.println(max);
}
/**
* 检查两个字符串中是否有相同的字符
* 转化为字符数组并排序，每次移动较小的字符
*/
private static boolean check(String str1, String str2) {
char[] chars1 = str1.toCharArray();
char[] chars2 = str2.toCharArray();
Arrays.sort(chars1);
Arrays.sort(chars2);
int i = 0, j = 0;
while (i < str1.length() && j < str2.length()) {
if (chars1[i] == chars2[j]) return true;
else if (chars1[i] > chars2[j]) j++;
else i++;
}
return false;
}
做法挺直接的，如果说字符都限定为小写字母的化，还能进一步优化
200 分题 3：学生方阵
学校组织活动，将学生排成一个矩形方阵。
请在矩形方阵中找到最大的位置相连的男生数量。
这个相连位置在一个直线上，方向可以是水平的，垂直的，成对角线的或者呈反对角线的。
注：学生个数不会超过10000
输入描述：输入的第一行为矩阵的行数和列数，接下来的n行为矩阵元素，元素间用”,”分隔。
输出描述：输出一个整数，表示矩阵中最长的位置相连的男生个数。
示例
输入
3,4
F,M,M,F
F,M,M,F
F,F,F,M
输出
3
输入
1,2
M,M
输出
2
输入
2,1
M
F
输出
1
点击查看代码
public static void main(String[] args) {
/*
获取输入
*/
Scanner in = new Scanner(System.in);
String[] str = in.nextLine().split(",");
int m = Integer.parseInt(str[0]);
int n = Integer.parseInt(str[1]);
// 构造矩阵
String[][] matrix = new String[m][n];
for (int i = 0; i < m; i++) {
String[] row = in.nextLine().split(",");
System.arraycopy(row, 0, matrix[i], 0, n);
}
// 从左往右，从上往下，对角线和反对角线
int[][] dp = new int[m][n];
int[][] dp2 = new int[m][n];
int[][] dp3 = new int[m][n];
int[][] dp4 = new int[m][n];
int ans = 0;
// 处理只有一行/一列的特例
if (m == 1) {
if (matrix[0][0].equals("M")) dp[0][0] = 1;
for (int j = 1; j < n; j++)
if (matrix[0][j - 1].equals("M")) {
// 如果是连续的长度加一
if (matrix[0][j].equals("M")) dp[0][j] = dp[0][j - 1] + 1;
} else {
// 不连续重新确定起点
if (matrix[0][j].equals("M")) dp[0][j] = 1;
}
for (int j = 0; j < n; j++) ans = Math.max(ans, dp[0][j]);
System.out.println(ans);
return;
}
if (n == 1) {
if (matrix[0][0].equals("M")) dp2[0][0] = 1;
for (int i = 1; i < m; i++) {
if (matrix[i - 1][0].equals("M")) {
if (matrix[i][0].equals("M")) dp2[i][0] = dp2[i - 1][0] + 1;
} else {
if (matrix[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;
}
/*
初始化准备开始动态规划
*/
for (int i = 0; i < m; i++) {
// 初始化列
if (matrix[i][0].equals("M")) {
dp[i][0] = 1;
dp2[i][0] = 1;
dp3[i][0] = 1;
}
}
for (int j = 0; j < n; j++) {
// 初始化行
if (matrix[0][j].equals("M")) {
dp[0][j] = 1;
dp2[0][j] = 1;
dp3[0][j] = 1;
dp4[0][j] = 1;
}
}
// 单独初始化dp4
for (int i = 0; i < m; i++) if (matrix[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 (matrix[i][j].equals("M")) {
dp[i][j] = dp[i][j - 1] + 1;
dp2[i][j] = dp2[i - 1][j] + 1;
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 (matrix[i][j].equals("M")) {
if (matrix[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(dp[i][j], Math.max(dp2[i][j], Math.max(dp3[i][j], dp4[i][j]))));
}
}
System.out.println(ans);
}
dp[i][j] 就代表了从左往右/上往下/对角线/反对角线，第 i 行 / 列 以 j 位置结尾的最大男生连续数量
