[java 版] 美团2021校招笔试

1. 淘汰分数

某比赛已经进入了淘汰赛阶段,已知共有n名选手参与了此阶段比赛，他们的得分分别是a_1,a_2….a_n,小美作为比赛的裁判希望设定一个分数线m，使得所有分数大于m的选手晋级，其他人淘汰。

但是为了保护粉丝脆弱的心脏，小美希望晋级和淘汰的人数均在[x,y]之间。

显然这个m有可能是不存在的，也有可能存在多个m，如果不存在，请你输出-1，如果存在多个，请你输出符合条件的最低的分数线。

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n=sc.nextInt();
        int x=sc.nextInt();
        int y=sc.nextInt();
        int m=-1;
        if(n<2*x||n>2*y){
            m=-1;
        }
        int a[]=new int[n];
        for(int i=0;i<n;i++){
            a[i]=sc.nextInt();
        }
        Arrays.sort(a);
        for(int i=0;i<n;i++){
            m=a[i];
            if(i+1>=x&&i+1<=y&&(n-i-1)>=x&&(n-i-1)<=y){
                break;
            }
        }
        System.out.println(m);
    }
}

2.正则序列

我们称一个长度为n的序列为正则序列，当且仅当该序列是一个由1~n组成的排列，即该序列由n个正整数组成，取值在[1,n]范围，且不存在重复的数，同时正则序列不要求排序

有一天小团得到了一个长度为n的任意序列s，他需要在有限次操作内，将这个序列变成一个正则序列，每次操作他可以任选序列中的一个数字，并将该数字加一或者减一。

请问他最少用多少次操作可以把这个序列变成正则序列？

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a[] = new int [n];
        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
        }
        int ans=0;
        Arrays.sort(a);
        for(int i=1;i<=n;i++){
            ans+=Math.abs(a[i-1]-i);
        }
        System.out.println(ans);
    }
}

3. 公司食堂

小美和小团所在公司的食堂有N张餐桌，从左到右摆成一排，每张餐桌有2张餐椅供至多2人用餐，公司职员排队进入食堂用餐。小美发现职员用餐的一个规律并告诉小团：当男职员进入食堂时，他会优先选择已经坐有1人的餐桌用餐，只有当每张餐桌要么空着要么坐满2人时，他才会考虑空着的餐桌；

当女职员进入食堂时，她会优先选择未坐人的餐桌用餐，只有当每张餐桌都坐有至少1人时，她才会考虑已经坐有1人的餐桌；

无论男女，当有多张餐桌供职员选择时，他会选择最靠左的餐桌用餐。现在食堂内已有若干人在用餐，另外M个人正排队进入食堂，小团会根据小美告诉他的规律预测排队的每个人分别会坐哪张餐桌。

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

public class Main {
    public static void main(String[] args) throws IOException{

        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));

        int t = Integer.parseInt(reader.readLine());
        while (t-- > 0) {
            int n = Integer.parseInt(reader.readLine());
            String map = reader.readLine();
            PriorityQueue<Integer> queue_m = new PriorityQueue<>();
            PriorityQueue<Integer> queue_f = new PriorityQueue<>();
            for (int i = 0; i < n; i++) {
                if (map.charAt(i) == '0') {
                    queue_f.add(i + 1);
                }
                if (map.charAt(i) == '1') {
                    queue_m.add(i + 1);
                }
            }
            List<Integer> ans=new ArrayList<>();
            int m = Integer.parseInt(reader.readLine());
            char []people = reader.readLine().toCharArray();
            for (Character p : people) {
                if (p == 'M') {
                    if (!queue_m.isEmpty()) {
                        ans.add(queue_m.poll());
                    } else {
                        int w = queue_f.poll();
                        ans.add(w);
                        queue_m.add(w);
                    }
                }
                if (p == 'F') {
                    if (!queue_f.isEmpty()) {
                        int w = queue_f.poll();
                        ans.add(w);
                        queue_m.add(w);
                    } else {
                        ans.add(queue_m.poll());
                    }
                }
            }
            for(Integer num:ans){
                writer.write(Integer.toString(num));
                writer.newLine();
            }
        }
        writer.flush();

    }
}

4. 最优二叉树II

小团有一个由N个节点组成的二叉树，每个节点有一个权值。定义二叉树每条边的开销为其两端节点权值的乘积，二叉树的总开销即每条边的开销之和。小团按照二叉树的中序遍历依次记录下每个节点的权值，即他记录下了N个数，第i个数表示位于中序遍历第i个位置的节点的权值。之后由于某种原因，小团遗忘了二叉树的具体结构。在所有可能的二叉树中，总开销最小的二叉树被称为最优二叉树。现在，小团请小美求出最优二叉树的总开销。

import java.util.*;

public class Main {
    static int [][]ldp;
    static int [][]rdp;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int [n+2];
        ldp=new int[n+2][n+2];
        rdp=new int [n+2][n+2];
        for(int i=1;i<=n;i++){
            a[i]=sc.nextInt();
        }
        for(int len=0;len<n;len++){
            for(int i=1;i<=n && i+len<=n;i++){
                getRes(i,i+len,a);
            }
        }
        System.out.println(ldp[1][n]);
    }
    public static void getRes(int l,int r,int []a){
        rdp[l][r]=ldp[l][r]=1000000000;
        for(int i=l;i<=r;i++){
            int x=ldp[l][i-1]+a[i]*a[r+1]+rdp[i+1][r];
            int y=ldp[l][i-1]+a[i]*a[l-1]+rdp[i+1][r];
            ldp[l][r]=Math.min(ldp[l][r],x);
            rdp[l][r]=Math.min(rdp[l][r],y);
        }
        
    }
}