用友2024秋招笔试题

第一题：

import java.util.Scanner;
import java.util.Stack;

/**
 * 题目描述：
 * 小友正在优化财务报表分析功能。给定一个由不同整数构成的数组revenues，每个元素表示在不同时间段内的收入。
 * 我们用以下方式定义一个与 revenues 长度相同的数组 maxDurations: 
 * maxDurations[i] 是一个子数组 revenues[l..r]的最大长度，该子数组中的最大收入等于revenues[i]
 * 返回数组 maxDurations。
 * 注意，子数组是数组的连续部分。 请用java语言给出算法答案
 * 优化财务报表：假设数组中的元素唯一
 */
public class T1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();//数组的长度
        int[] revenues = new int[N];//不同整数构成的数组
        System.out.println();
        for (int i = 0; i < N; i++){
            revenues[i] = sc.nextInt();
        }

        int[] maxDurations = new int[N];//用于存储结果
        int[] left = new int[N];//当前i能够扩展到的最左索引
        int[] right = new int[N];//当前i能够扩展到的最右索引
        for (int i = 0; i < N; i++){
            left[i] = i;
            right[i] = i;
        }
        Stack<Integer> stack = new Stack<>();
        //每个元素作为最大值时能向左扩展到的最远距离
        for (int i = 0; i < N; i++){
            //搜索最左索引
            while (!stack.isEmpty() && revenues[i] > revenues[stack.peek()]){
                stack.pop();
            }
            //栈顶元素比当前元素大了
            left[i] = stack.isEmpty() ? 0 : stack.peek() + 1;
            stack.push(i);
        }
        stack.clear();

        //每个元素作为最大值时能向右扩展到的最远距离
        for (int i = N-1; i >= 0; i--){
            while (!stack.isEmpty() && revenues[i] >= revenues[stack.peek()]){
                stack.pop();
            }
            right[i] = stack.isEmpty() ? N-1 : stack.peek() - 1;
            stack.push(i);
        }
        //计算maxDurations
        for (int i = 0; i < N; i++){
            maxDurations[i] = right[i] - left[i] + 1;
        }

        for (int maxDuration : maxDurations) {
            System.out.print(maxDuration + " ");
        }

        sc.close();

    }
}

第二题：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

/**
 * 题目描述：
 * 小友负责维护公司的电力供应网络。公司由nxn的网格组成，每个单元格代表一个区域。区域中有些有电力设施(用1表示)，
 * 有些则没有(用0表示)。为了保证公司的电力供应，必须让每个没有电力设施的区域能够尽量靠近一个有电力设施的区域。
 * 你需要找到一个没有电力设施的区域，这个区域到最近的有电力设施的区域的距离是最大的，并返回该距离。
 * 如果整个公司都是有电力设施的区域或者没有电力设施的区域，请返回 -1。
 * 注意:(x0,y0)和 (x1,y1)这两个区域之间的距离是 |x0-x1|+ |y0 -y1|。
 *
 * 输入描述：
 * 输入整数 N
 * 输入代表公司各个区域是否有电力设施的 NxN 矩阵的各个元素(0代表无电力设施区域，1代表有电力设施区域)
 *
 * 输出描述：
 * 输出整数 distantce，代表所有无电力设施区域中到最近的有电力设施区域距离的最大值
 */
public class T2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[][] grid = new int[n][n];

        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < n; i++){
            for (int j = 0; j < n; j++){
                grid[i][j] = sc.nextInt();
                if (grid[i][j] == 1){
                    queue.offer(new int[]{i, j});
                }
            }
        }
        if (queue.isEmpty() || queue.size() == n*n){//没有电力设施或者全是电力设施，返回-1
            System.out.println(-1);
        }

        int distance = -1;
        int[][] directions = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};

        while (!queue.isEmpty()){//bfs
            int size = queue.size();
            distance++;
            for (int i = 0; i < size; i++){//遍历当前队列中的每个元素
                int[] point = queue.poll();
                int x = point[0];
                int y = point[1];
                for (int[] dir : directions) {
                    int newX = dir[0];
                    int newY = dir[1];
                    if (newX < 0 || newX >= n || newY < 0 || newY <= n){
                        continue;
                    }
                    if (grid[newX][newY] == 0){
                        grid[newX][newY] = 1;//标记为已访问
                        queue.offer(new int[]{newX, newY});
                    }
                }
            }
        }
        System.out.println(distance);
    }
}