华为秋招机试三道编程题（2021-08-25）

恭喜发现宝藏！微信搜索公众号【TechGuide】关注更多新鲜好文和互联网大厂的笔经面经。
作者@TechGuide【全网同名】
点赞再看，养成习惯，您动动手指对原创作者意义非凡🤝

提示

1. 华为最后一次机试在9月1日，抓紧啦！

2. 笔试仅作面试参考，100分即可，低分也不必过于纠结，好好准备面试！

第一道：最大子矩阵（100%）

题目描述

求矩阵的最大子矩阵，比较大小的依据是子矩阵所有元素和的大小

参考代码：

import java.io.BufferedInputStream;
import java.util.Scanner;

class TechGuide{
    public void main(){
        Scanner s=new Scanner(new BufferedInputStream(System.in));
        int m=s.nextInt();
        int n=s.nextInt();
        int[][] martrix=new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                martrix[i][j]=s.nextInt();
            }
        }
        int ans=Integer.MIN_VALUE;
        for (int i = 0; i <m ; i++) {
            int[] dp=new int[n];
            for (int j = i; j < m; j++) {
                for (int k = 0; k < n; k++) {
                    dp[k]+=martrix[j][k];
                }
                int[] sum=new int[n];
                int min=0;
                for (int k = 0; k < n; k++) {
                    sum[k]+=dp[k];
                    if (k>0)sum[k]+=sum[k-1];
                    ans=Math.max(ans,sum[k]-min);
                    min=Math.min(min,sum[k]);
                }
            }

        }
        System.out.println(ans);
    }
}
// 关注TechGuide！ 大厂笔经面经闪电速递！

第二道： 最短时间（100%）

题目描述

一个m×n的矩阵，每个元素是一个计时器，只有在计时器不为0时才能进入，每走一步所有计时器减一，求从(0, 0)到(m-1, n-1)的最短时间

参考代码

BFS搜索加剪枝

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

class TechGuide{
    int row,col;
    int[] dx={-1,1,0,0};
    int[] dy={0,0,1,-1};
    public void main(){
        Scanner s=new Scanner(new BufferedInputStream(System.in));
        row=s.nextInt();
        col=s.nextInt();
        int[][] grid=new int[row][col];
        for (int i = 0; i <row ; i++) {
            for (int j = 0; j < col; j++) {
                grid[i][j]=s.nextInt();
            }
        }
        System.out.println(getAns(grid));

    }
    private int getAns(int[][] grid){
        if (grid[0][0]<=0){
            return -1;
        }
        int[][] minTime=new int[row][col];
        for (int i = 0; i < row; i++) {
            Arrays.fill(minTime[i],Integer.MAX_VALUE);
        }
        Queue<Node> queue=new LinkedList<>();
        queue.add(new Node(0,0,0));
        while (!queue.isEmpty()){
            Node node=queue.poll();
            int x=node.x;
            int y=node.y;
            int hop=node.hop;
            if (minTime[x][y]<=hop||grid[x][y]<hop)continue;
            minTime[x][y]=hop;
            if (x==row-1&&y==col-1)return hop;
            for (int i = 0; i < dx.length; i++) {
                int nextX=dx[i]+x;
                int nextY=dy[i]+y;
                if (!inGrid(nextX,nextY))continue;
                queue.add(new Node(nextX,nextY,hop+1));
            }
        }
        return -1;
    }
    
    private boolean inGrid(int x,int y){
        return x>=0&&x<row&&y>=0&&y<col;
    }
        private class Node{
        int x;
        int y;
        int hop;

        public Node(int x, int y, int hop) {
            this.x = x;
            this.y = y;
            this.hop = hop;
        }
    }
}
// 关注TechGuide！ 大厂笔经面经闪电速递！

第三道：最快完成时间（100%）

题目描述

给定任务依赖关系，求完成所有任务所需的最短时间

思路解析

拓扑排序 + 动态规划，状态转移方程为：

其中dp[i]代表完成第i个任务需要的时间。

参考代码

import java.io.BufferedInputStream;
import java.util.*;

class TechGuide{
    public void main(){
        Scanner s=new Scanner(new BufferedInputStream(System.in));
        int n=s.nextInt();
        int[] times=new int[n];
        s.nextLine();
        List<List<Integer>> graph=new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new ArrayList<>());
        }
        for (int i = 0; i < n; i++) {
            String str=s.nextLine();
            String[] strs=str.split(",");
            for (int j = 0; j <strs.length-1 ; j++) {
                int a=Integer.parseInt(strs[j]);
                graph.get(a).add(i);
            }
            String[] curr=strs[strs.length-1].split(" ");
            if (!curr[0].equals("-1")){
                int a=Integer.parseInt(curr[0]);
                graph.get(a).add(i);
            }
            int t=Integer.parseInt(curr[1]);
            times[i]=t;
        }
        System.out.println(getAns(times,graph,n));
    }
    private int getAns(int[] times,List<List<Integer>> graph,int n){
        int[] in=new int[n];
        for(List<Integer> list:graph){
            for(int i:list)in[i]++;
        }
        Queue<Integer> queue=new LinkedList<>();
        int[] dp=new int[n];
        Arrays.fill(dp,0);
        int cnt=0;
        for (int i = 0; i < n; i++) {
            if (in[i]==0){
                dp[i]=times[i];
                queue.add(i);
            }
        }
        while (!queue.isEmpty()){
            int curr=queue.poll();
            cnt++;
            for(int i:graph.get(curr)){
                in[i]--;
                dp[i]=Math.max(dp[i],dp[curr]+times[i]);
                if (in[i]==0)queue.add(i);
            }
        }
        if (cnt!=n)return -1;
        int ans=0;
        for (int i = 0; i <dp.length ; i++) {
            ans=Math.max(ans,dp[i]);
        }
        return ans;
    }

}

恭喜发现宝藏！微信搜索公众号【TechGuide】关注更多新鲜好文和互联网大厂的笔经面经。