2021美团笔试题（第十套）个人解答

最新推荐文章于 2024-08-11 10:25:57 发布

Ant_Davis

最新推荐文章于 2024-08-11 10:25:57 发布

阅读量3.8k

点赞数 2

分类专栏：美团笔试文章标签：动态规划 javac

本文链接：https://blog.csdn.net/flyersboy/article/details/117329832

版权

美团笔试专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文探讨了多种算法问题的解决方案，包括竞赛淘汰分数的确定、正则数列的计算、糕点问题的模拟以及回转寿司的最大美味值求解。文章通过动态规划的方法解决了连续子数组的最大和问题，并分析了环形数组特殊情况的处理。此外，还涉及了在限定晋级人数条件下的淘汰策略。内容涵盖了数组操作、排序、条件判断和集合的使用，展示了算法在解决实际问题中的应用。

摘要由CSDN通过智能技术生成

1、淘汰分数

在这里插入图片描述

//暴力解法
import java.util.Arrays;
import java.util.Scanner;
/*
 * 先排序，从最小值开始遍历，判断两者人数是否符合人数区间
 * 注意：考虑存在多个分数线时，要输出最低的，所以要排序
 * */
public class EliminateScores {
 	public static int findEliminateScores(int min, int max, int[] scores) {
        if (min > max) return -1;
        int rs;//结果分数线
        //分数得先排序
        Arrays.sort(scores);
 
        for (int i = 0; i < scores.length; i++) {
            int temp = scores[i];
            int higherNum = 0;//分高
            int lowerNum = 0;//分低
 
            //统计晋级淘汰人数
            for (int j = 0; j < scores.length; j++) {
                if (temp < scores[j])
                    higherNum++;
                else lowerNum++;
 
                if (higherNum > max || lowerNum > max) break;
            }
 
            if (higherNum <= max && higherNum >= min && lowerNum <= max && lowerNum >= min) {
                rs = temp;
                return rs;
            }
        }
 
        return -1;
    }
 
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
 
        int playerNum = s.nextInt();//参赛
        int min = s.nextInt();//晋级淘汰下限
        int max = s.nextInt();//晋级淘汰上限
        int[] scores = new int[playerNum];
        for (int i = 0; i < playerNum; i++) {
            scores[i] = s.nextInt();
        }
 
        int rs = findEliminateScores(min, max, scores);
        System.out.println(rs);
    }
}

//遍历x到y这个区间
import java.util.Arrays;
import java.util.Scanner;
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[] num = new int[n];
        for (int i = 0; i < n; i++) {
            num[i] = sc.nextInt();
        }
 
        int success = 0;
        int defeat = 0;
        Arrays.sort(num);
        if((2*x > n) || (2*y < n)){
            System.out.println(-1);
        }
        for(int i=x;i<=y;i++){
           defeat = i;
           success = n - defeat;
           if(success >= x && success <= y)   break;
       }
 
        System.out.println(num[defeat - 1]);
    }
}

2、正则数列

在这里插入图片描述

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = in.nextInt();
        }
        Arrays.sort(arr);

        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum+=(Math.abs(arr[i]-(i+1)));
        }
        System.out.println(sum);
    }
}

3、糕点问题

在这里插入图片描述

模拟一下，在保证a<b的情况下，有如下几种情况：

(1) 已经烤好的蛋糕中，重量最小的比a轻，或者重量最大的比b重，肯定无法满足要求。

(2) 已经烤好的蛋糕重量都在区间[a,b]中

i) 已经有a和b两个重量，可以满足要求。

ii) 已经有a或b之中的一个重量，并且还能现烤的蛋糕数不少于1，那就肯定还能够烤一个需要的重量；否则不能满足要求。

iii) 需要的两个重量都没有，并且能还能现烤的蛋糕数不少于2，那就肯定可以把需要的两个重量都烤了；否则不能满足要求。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashSet;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        String[] params;
        while((line = br.readLine()) != null) {
            params = line.trim().split(" ");
            int n = Integer.parseInt(params[0]);
            int m = Integer.parseInt(params[1]);
            int a = Integer.parseInt(params[2]);
            int b = Integer.parseInt(params[3]);
            params = br.readLine().trim().split(" ");
            int[] weight = new int[m];
            HashSet<Integer> set = new HashSet<>(); // 保存现有蛋糕的重量
            for(int i = 0; i < m; i++) {
                weight[i] = Integer.parseInt(params[i]);
                set.add(weight[i]);
            }
            Arrays.sort(weight);
            // 保证a<b
            if(a > b){
                int temp = a;
                a = b;
                b = temp;
            }
            if(weight[0] < a || weight[m - 1] > b){
                // 现有蛋糕中，重量最小的小于a，最大的大于b，肯定完成不了需求
                System.out.println("NO");
            }else{
                if(set.contains(a) && set.contains(b))   
                    // 如果现有蛋糕中已经包含了a和b，就没问题
                    System.out.println("YES");
                else{
                    if(set.contains(a) || set.contains(b)){
                        // 如果只包含a或b，检查一下n-m是否大于等于1，即还有一个重量需要现烤
                        System.out.println(n - m >= 1 && weight[m - 1] <= b? "YES": "NO");
                    }else{
                        // 否则需要检查n-m是否大于等于2，即两个重量都需要现烤
                        System.out.println(n - m >= 2? "YES": "NO");
                    }
                }
            }
        }
    }
}

4、回转寿司

在这里插入图片描述

题目要求环形数组的连续子数组的最大和，我们先不要去管数组是环形的情况，利用动态规划求解连续子数组的最大和以及最小和。

(1) 不考虑环形得到的最大值：题中允许寿司首尾相连的环形数组情况，因此常规求得的连续子数组的最大和就是我们排除这种情况之外的所有情况中的最大和。

(2) 只考虑环形得到的最大值：而对于首尾相连的情况，我们可以这样考虑，如果常规求得的连续子数组的和达到了最小，那么总和减去这个最小值就等于首尾相连情况的最大值了。

因此最大的美味值就是(1)和(2)两种情况中大的那个。

---------------------------------------------------------------------------------------------------------------------------

接下来说一下动态规划如何求解连续子数组的最大和：

状态定义：dp[i]表示以 i 结尾的连续子数组的最大和
状态转移方程：dp[i] = max(array[i], dp[i-1]+array[i])
状态转移方程的意思是：如果选择了当前元素i，而**dp[i-1]为负数，表明之前的和做的是负贡献，会使得整体的和变小，因此这时候选择从array[i]**重新开始计算和。

考虑到我们并不需要求得dp数组中所有的值，而是只需要最大值，所以还可以对空间复杂度进行优化。每次计算得到其中一个**dp[i]时，就更新当前的最大值，而dp[i]**之前的取值(dp[0],dp[1],…,dp[i-1])已经用过，所以不需要再保留了，仅用一个变量代替dp数组即可。

求解连续子数组的最小和只要将以上的max改成min就可以了…

---------------------------------------------------------------------------------------------------------------------------

为什么原始数组的和 — 原始数组的连续最小和 =环状数组的连续最大和？

最大和有两种可能，一个是选取的元素中首尾没有同时出现（即不成环的情况），另外一个就是首尾同时出现（成环），第二种情况意味着没有选到的元素在不成环时也连在一起，因此只要让这些没选到的元素最小就行。

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int T = Integer.parseInt(br.readLine().trim());
        while(T-- > 0){
            int n = Integer.parseInt(br.readLine().trim());
            String[] strArr = br.readLine().trim().split(" ");
            int[] yummy = new int[n];
            int sum = 0;
            for(int i = 0; i < n; i++){
                yummy[i] = Integer.parseInt(strArr[i]);
                sum += yummy[i];
            }
            // 为了降低时间复杂度，可以两种情况一起求
            int max = yummy[0];
            int min = yummy[0];
            int dpMax = yummy[0];
            int dpMin = yummy[0];
            for(int i = 1; i < n; i++){
                dpMax = Math.max(dpMax + yummy[i], yummy[i]);
                max = Math.max(max, dpMax);
                dpMin = Math.min(dpMin + yummy[i], yummy[i]);
                min = Math.min(min, dpMin);
            }
            System.out.println(Math.max(sum - min, max));
        }
    }
}

这一题类似LeetCode53—最大子序和问题

class Solution {
    public int maxSubArray(int[] nums) {
        int maxSum = nums[0];
        int tempSum = nums[0];
        for(int i=1;i<nums.length;i++){
            if(tempSum<=0){
                tempSum = nums[i];
            }else{
                tempSum+=nums[i];
            }
            if(maxSum<tempSum){
                maxSum = tempSum;
            }
        }
        return maxSum;
    }
}

5、晋级人数

在这里插入图片描述

import java.io.*;
import java.util.Arrays;
public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] s = br.readLine().trim().split(" ");
        int n = Integer.parseInt(s[0]);
        int x = Integer.parseInt(s[1]);

        int[] arr = new int[n];
        s = br.readLine().trim().split(" ");
        for(int i = 0; i < n; i++){
            arr[i] = Integer.parseInt(s[i]);
        }
        int res = 0;
        int len = arr.length;
        Arrays.sort(arr);
        int base = arr[n - x];
        for(int i = 0; i < n; i++){
            if(arr[i] == 0) continue;
            else if(arr[i] == base) {
                res =n - i;
                break;
            }
        }
        System.out.println(res);
    }
}

我觉得这题多多少少有点问题

如果出现0 0 0 3 4 这种情况，按理说只能通过3 4 两个，但是实际输出还是为3

Ant_Davis

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
2021美团笔试题（第十套）个人解答

1、淘汰分数//暴力解法import java.util.Arrays;import java.util.Scanner;/* * 先排序，从最小值开始遍历，判断两者人数是否符合人数区间 * 注意：考虑存在多个分数线时，要输出最低的，所以要排序 * */public class EliminateScores { public static int findEliminateScores(int min, int max, int[] scores) { if (min
复制链接

扫一扫