华为2021.8.25笔试复盘

第一题 ：最大子矩阵 

　给定一个二维整数矩阵，选其中一个子矩阵，使得这个子矩阵内的所有数字和是最大的。

输入
第一行n m ∈[1，10] 表示矩阵大小；
下面多行表示输入矩阵，元素大小在[-1000，1000]；
输出
输出一个整数，代表最大和

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

public class Main164 {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String[] s1 = s.split(" ");
        int n = Integer.parseInt(s1[0]);
        int m = Integer.parseInt(s1[1]);
        int[][] matrix = new int[n][m];
        ArrayList<String> strings = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                matrix[i][j] = scanner.nextInt();
            }
        }

        System.out.println(getMaxMatrixSum(matrix));
    }

    public static int getMaxMatrixSum(int[][] matrix){
        int n = matrix.length;
        int m = matrix[0].length;

        int[] dp = new int[m];
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            Arrays.fill(dp, 0);
            for (int j = i; j < n; j++) {
                int bef = 0;
                for (int k = 0; k < m; k++) {
                    dp[k] += matrix[j][k];
                    if (bef > 0){
                        bef += dp[k];
                    }else {
                        bef = dp[k];
                    }

                    if (bef > max){
                        max = bef;
                    }
                }
            }
        }
        return max;
    }
}

第二题：逃出生天
给一张row*col地图，地图上每个点都有一个倒计时装置，为0就会成陷阱，使得这个点不能通过，在地图上每移动一个点消耗1s。可以上下左右移动，
请找到一条最佳路线，在最短时间内从起点[0，0]到终点[row-1，col-1]。
输入
第一行 row col ∈[1,15];
下面多行代表地图，元素大小为倒计时，∈[0，100]；

输出
最短时间，若没有，输出-1

import java.util.Scanner;

public class Main {
    private static int min;
    private static boolean[][] flag;
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        String[] s1 = s.split(" ");
        int row = Integer.parseInt(s1[0]);
        int col = Integer.parseInt(s1[1]);
        int[][] matrix = new int[row][col];
        flag = new boolean[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                matrix[i][j] = scanner.nextInt();
            }
        }
        min = Integer.MAX_VALUE;
        dfs(matrix, 0, 0, row, col, 0);
        System.out.println(min == Integer.MAX_VALUE ? -1 : min);
    }

    public static void dfs(int[][] matrix, int curRow, int curCol, int row, int col, int time){
        if (curRow < 0 || curRow >= row || curCol < 0 || curCol >= col || flag[curRow][curCol]){
            return;
        }else if (time >= matrix[curRow][curCol]){
            return;
        }else if (curRow == row - 1 && curCol == col - 1){
            min = Math.min(time, min);
            return;
        }
        flag[curRow][curCol] = true;
        dfs(matrix,curRow -1, curCol, row, col, time + 1);
        dfs(matrix,  curRow + 1, curCol, row, col, time + 1);
        dfs(matrix, curRow, curCol - 1, row, col, time + 1);
        dfs(matrix,  curRow, curCol + 1, row, col, time + 1);
        flag[curRow][curCol] = false;
    }
}

第三题 任务调度
需要完成一系列任务，任务之间存在依赖关系，比如A依赖B，那么A必须在B完成后才能做。
给出n个任务的依赖关系和运行时间，n<=10000，计算这n个任务执行完成所需要的时间，如果有依赖循环输出-1。

输入

第一行 任务个数n

下面多行为n个任务的信息，第一部分为依赖的任务ID，为整数，索引从0开始，第二部分为运行时间。

任务可能依赖多个其他任务，多个任务ID用逗号分隔，如果任务不依赖其他任何任务，依赖ID为-1。

输出
所有任务运行完所需要的时间，若依赖循环则-1.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;


public class Main166 {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s = reader.readLine();
        int n = Integer.parseInt(s);    //任务数
        int[] time = new int[n];        //任务所需时间
        int[] indge = new int[n];       //任务的入度
        ArrayList<List<Integer>> edges = new ArrayList<>();   //保存依赖
        for (int i = 0; i < n; i++) {
            edges.add(new ArrayList<>());
        }

        for (int i = 0; i < n; i++) {
            String s1 = reader.readLine();
            String[] s2 = s1.split(" ");
            String[] split = s2[0].split(",");      //任务的前置任务
            int t = Integer.parseInt(s2[1]);             //任务所花时间
            time[i] = t;
            for (String ttt : split){
                int pre = Integer.parseInt(ttt);
                if (pre != -1){
                    edges.get(pre).add(i);
                    ++indge[i];
                }
            }
        }

        int ans = new Solution166().finishTime(edges, indge, time, n);
        System.out.println(ans);
    }
}

class Solution166{
    public int finishTime(List<List<Integer>> edges, int[] indges, int[] time, int n){
        int[] dp = new int[n];            //保存但当前任务以及其前序任务执行完所需时间

        LinkedList<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (indges[i] == 0){
                queue.offer(i);
                dp[i] = time[i];
            }
        }

        ArrayList<Integer> res = new ArrayList<>();  //保存已执行的任务
        while (!queue.isEmpty()){
            int u = queue.poll();
            res.add(u);
            for (int v : edges.get(u)){
                --indges[v];
                dp[v] = Math.max(dp[u] + time[v], dp[v]);
                if (indges[v] == 0){
                    queue.offer(v);
                }
            }
        }

        if (res.size() != n){
            return -1;
        }

        int max = Integer.MIN_VALUE;
        for (int t : dp){
            max = Math.max(t, max);
        }
        return max;
    }
}