【美团笔试题汇总】2023-08-26-美团春秋招笔试题-三语言题解(CPP/Python/Java)

🍭 大家好这里是KK爱Coding ,一枚热爱算法的程序员

✨ 本系列打算持续跟新小米近期的春秋招笔试题汇总~

💻 ACM银牌🥈| 多次AK大厂笔试 | 编程一对一辅导

👏 感谢大家的订阅➕ 和 喜欢💗

📧 KK这边最近正在收集近一年互联网各厂的笔试题汇总,如果有需要的小伙伴可以关注后私信一下 KK领取,会在飞书进行同步的跟新。

**

💻听说明天上午要笔美团啦,这里给大家带来一些去年秋招的题目来练练手。

🎉 祝大家明天超常发挥,笔试AK,rp ++++++

**

文章目录

    • 💻听说明天上午要笔美团啦,这里给大家带来一些去年秋招的题目来练练手。
    • 🎉 祝大家明天超常发挥,笔试AK,rp `++++++`
    • 01.K小姐的植物浇水
      • 问题描述
      • 输入格式
      • 输出格式
      • 样例输入
      • 样例输出
      • 数据范围
      • 题解
      • 参考代码
    • 02.LYA 的公寓租金分摊
      • 问题描述
      • 输入格式
      • 输出格式
      • 样例输入
      • 样例输出
      • 数据范围
      • 题解
      • 参考代码
    • 03.LYA的魔药配方
      • 问题描述
      • 输入格式
      • 输出格式
      • 样例输入
      • 样例输出
      • 数据范围
      • 题解
      • 参考代码
    • 04.K小姐的礼物盒
      • 问题描述
      • 输入格式
      • 输出格式
      • 样例输入
      • 样例输出
      • 数据范围
      • 题解
      • 参考代码
    • 05.LYA 的平均分目标
      • 问题描述
      • 输入格式
      • 输出格式
      • 样例输入
      • 样例输出
      • 数据范围
      • 题解
      • 参考代码
    • 写在最后
    • 📧 KK这边最近正在收集近一年互联网各厂的笔试题汇总,如果有需要的小伙伴可以关注后私信一下 KK领取,会在飞书进行同步的跟新。

01.K小姐的植物浇水

问题描述

K小姐有一盆植物,她希望能够在最短的时间内让植物长到至少 z z z 厘米高。目前植物的高度为 0 0 0 厘米。

每天,K小姐可以选择以下两种浇水方式之一:

  1. x x x 毫升的水,植物高度增加 x x x 厘米。
  2. y y y 毫升的水,植物高度增加 y y y 厘米。需要注意的是,使用第二种浇水方式后,必须至少等待两天才能再次使用该方式。

请你帮助K小姐计算出让植物长到至少 z z z 厘米高所需的最少天数。

输入格式

输入一行,包含三个整数 x x x y y y z z z,分别表示两种浇水方式的水量以及目标植物高度。

输出格式

输出一个整数,表示让植物长到至少 z z z 厘米高所需的最少天数。

样例输入

1 2 10

样例输出

6

数据范围

  • 1 ≤ x , y , z ≤ 1 0 9 1 \leq x, y, z \leq 10^9 1x,y,z109

题解

本题可以使用二分查找的思想来解决。我们可以二分枚举所需的天数 d d d,判断在 d d d 天内是否能够让植物长到至少 z z z 厘米高。

对于每个枚举的天数 d d d,我们可以计算出在这 d d d 天内使用第二种浇水方式的最大次数为 ⌊ d 3 ⌋ \lfloor \frac{d}{3} \rfloor 3d。然后,我们可以计算出在这 d d d 天内,使用第一种浇水方式的次数为 d − ⌊ d 3 ⌋ d - \lfloor \frac{d}{3} \rfloor d3d

因此,在 d d d 天内,植物的最大高度为:

h e i g h t = x × ( d − ⌊ d 3 ⌋ ) + y × ⌊ d 3 ⌋ height = x \times (d - \lfloor \frac{d}{3} \rfloor) + y \times \lfloor \frac{d}{3} \rfloor height=x×(d3d⌋)+y×3d

如果 h e i g h t ≥ z height \geq z heightz,说明在 d d d 天内可以让植物长到至少 z z z 厘米高,我们可以缩小二分的范围;否则,我们需要增大二分的范围。

通过二分查找,我们可以找到最小的满足条件的天数。

时间复杂度: O ( log ⁡ z ) O(\log z) O(logz),其中 z z z 为目标植物高度。
空间复杂度: O ( 1 ) O(1) O(1)

参考代码

  • Python
def is_feasible(d, x, y, z):
    num = (d // 3) * y + d * x
    if d % 3 != 0:
        num += y
    return num >= z

x, y, z = map(int, input().split())
left, right = 0, z // x + 1
while left < right:
    mid = (left + right) // 2
    if is_feasible(mid, x, y, z):
        right = mid
    else:
        left = mid + 1
print(right)

  • Java
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        int z = scanner.nextInt();
        int left = 0, right = z / x + 1;
        while (left < right) {
            int mid = (left + right) / 2;
            if (isFeasible(mid, x, y, z)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        System.out.println(right);
    }

    public static boolean isFeasible(int d, int x, int y, int z) {
        long num = (d / 3) * y + d * x;
        if (d % 3 != 0) {
            num += y;
        }
        return num >= z;
    }
}

  • Cpp
#include <iostream>
using namespace std;

int x, y, z;

bool isFeasible(int d) {
    long long int num = (d / 3) * y + d * x;
    if (d % 3) {
        num += y;
    }
    return num >= z;
}

int main() {
    cin >> x >> y >> z;
    int left = 0, right = z / x + 1;
    while (left < right) {
        int mid = (left + right) / 2;
        if (isFeasible(mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    cout << right;
    return 0;
}

02.LYA 的公寓租金分摊

问题描述

LYA 是一位年轻有为的创业者,她在城市里拥有 n n n 栋公寓楼。每栋公寓楼都有若干名租户入住,LYA 自己也在每栋楼里保留了一个住处。现在,是每个月向租户们收取租金的时候了。

对于第 i i i 栋公寓楼,共有 k i k_i ki 名租户(包括 LYA 自己),月租总金额为 c i c_i ci。为了公平起见,LYA 决定将总租金 c i c_i ci 平均分摊给所有租户(包括她自己),每人需支付 ⌈ c i k i ⌉ \lceil \frac{c_i}{k_i} \rceil kici 的金额。这里, ⌈ x ⌉ \lceil x \rceil x 表示对实数 x x x 向上取整。

现在,LYA 希望你能帮她计算每位租户需要支付的租金金额。

输入格式

第一行包含两个正整数 n n n m m m,分别表示 LYA 拥有的公寓楼数量和城市中租户的总数。 ( 1 < n , m ≤ 1 0 5 ) (1 < n, m \le 10^5) (1<n,m105)

接下来有 2 n 2n 2n 行,每两行描述一栋公寓楼的信息:

  • 第一行包含两个整数 k i k_i ki c i c_i ci,分别表示该公寓楼的租户总数(包括 LYA)和月租总金额。 ( 2 ≤ k i ≤ m + 1 , 1 ≤ c i ≤ 1 0 9 ) (2 \le k_i \le m+1, 1 \le c_i \le 10^9) (2kim+1,1ci109)
  • 第二行包含 k i − 1 k_i-1 ki1 个整数,表示每位租户(不包括 LYA)的编号。租户编号在 1 1 1 m m m 之间。

输出格式

输出包含 m m m 个整数,第 i i i 个整数表示编号为 i i i 的租户需要支付的租金金额。

样例输入

2 3
3 10
1 2
4 10
1 2 3

样例输出

7 7 3

数据范围

  • 1 < n , m ≤ 1 0 5 1 < n, m \le 10^5 1<n,m105
  • 2 ≤ k i ≤ m + 1 2 \le k_i \le m+1 2kim+1
  • 1 ≤ c i ≤ 1 0 9 1 \le c_i \le 10^9 1ci109
  • 租户编号在 1 1 1 m m m 之间

题解

本题要求我们计算每位租户需要支付的租金金额。由于 LYA 自己也算作一名租户,因此每栋公寓楼的实际租户数为输入的 k i − 1 k_i-1 ki1

我们可以先创建一个长度为 m m m 的数组 rent,用于存储每位租户的租金金额,初始值都为 0 0 0

然后,对于每栋公寓楼,我们计算出每位租户需要支付的租金金额 ⌈ c i k i ⌉ \lceil \frac{c_i}{k_i} \rceil kici,然后将其累加到对应租户的租金金额上。

最后,我们将 rent 数组中的租金金额按顺序输出即可。

时间复杂度为 O ( n × k ˉ ) O(n \times \bar{k}) O(n×kˉ),其中 k ˉ \bar{k} kˉ 为每栋公寓楼的平均租户数。空间复杂度为 O ( m ) O(m) O(m)

参考代码

  • Python
n, m = map(int, input().split())
rent = [0] * m

for _ in range(n):
    k, c = map(int, input().split())
    cost = (c + k - 1) // k
    
    for x in map(int, input().split()):
        rent[x - 1] += cost

print(*rent)
  • Java
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] nm = br.readLine().split(" ");
        int n = Integer.parseInt(nm[0]);
        int m = Integer.parseInt(nm[1]);

        long[] rent = new long[m];
        for (int i = 0; i < n; ++i) {
            String[] kc = br.readLine().split(" ");
            int k = Integer.parseInt(kc[0]);
            int c = Integer.parseInt(kc[1]);
            long cost = (c + k - 1) / k;
            
            StringTokenizer st = new StringTokenizer(br.readLine());
            while (st.hasMoreTokens()) {
                int x = Integer.parseInt(st.nextToken());
                rent[x - 1] += cost;
            }
        }
        
        System.out.println(Arrays.stream(rent).mapToObj(Long::toString).collect(Collectors.joining(" ")));
    }
}
  • Cpp
#include <iostream>
using namespace std;

int main() {
    int n, m;
    cin >> n >> m;
    long long rent[m] = {0};
    
    for (int i = 0; i < n; ++i) {
        int k, c;
        cin >> k >> c;
        long long cost = (c + k - 1) / k;
        
        for (int j = 0; j < k - 1; ++j) {
            int x;
            cin >> x;
            rent[x - 1] += cost;
        }
    }
    
    for (int i = 0; i < m; ++i) {
        cout << rent[i] << (i == m - 1 ? "\n" : " ");
    }
    
    return 0;
}

03.LYA的魔药配方

问题描述

LYA是一位天才的魔药师,她有一个包含 n n n 种材料的魔药配方。每种材料都有一个初始的魔力值 a i a_i ai

为了制作出更加强大的魔药,LYA可以进行最多 m m m 次魔力调整操作。每次操作如下:

  1. 选择两种不同的材料,设它们的下标为 i i i j j j 1 ≤ i < j ≤ n 1 \leq i < j \leq n 1i<jn)。
  2. 选择两个正整数 x x x y y y,满足 x × y = a i × a j x \times y = a_i \times a_j x×y=ai×aj
  3. 将第 i i i 种材料的魔力值变为 x x x,第 j j j 种材料的魔力值变为 y y y

LYA想知道,在最多进行 m m m 次操作后,魔药配方中所有材料的魔力值之和最大可以达到多少。

输入格式

第一行包含两个整数 n n n m m m,分别表示魔药材料的数量和最多可以进行的操作次数。

第二行包含 n n n 个整数 a 1 , a 2 , … , a n a_1, a_2, \dots, a_n a1,a2,,an,表示初始时每种材料的魔力值。

输出格式

输出一个整数,表示在最多进行 m m m 次操作后,魔药配方中所有材料的魔力值之和的最大值。

由于答案可能很大,请输出答案对 1 0 9 + 7 10^9+7 109+7 取模的结果。

样例输入

6 2
1 2 3 4 5 6

样例输出

128

数据范围

  • 1 ≤ m < n ≤ 1 0 5 1 \leq m < n \leq 10^5 1m<n105
  • 1 ≤ a i ≤ 1 0 5 1 \leq a_i \leq 10^5 1ai105

题解

本题可以使用贪心算法来解决。

为了使最后的魔力值之和最大,我们需要尽可能地将较大的魔力值调整得更大。具体策略如下:

  1. 将材料按照魔力值从小到大排序。
  2. 从最大的两个魔力值开始,将它们的乘积赋值给最大的魔力值,并将次大的魔力值设为 1 1 1
  3. 重复步骤 2,直到进行了 m m m 次操作或者无法继续操作为止。
  4. 计算所有材料的魔力值之和并输出结果。

时间复杂度为 O ( n log ⁡ n ) O(n \log n) O(nlogn),空间复杂度为 O ( n ) O(n) O(n)

参考代码

  • Python
n, m = map(int, input().split())
a = list(map(int, input().split()))
mod = 10**9 + 7

a.sort()
ptr1, ptr2 = n - 2, n - 1

for i in range(m):
    if ptr1 < 0:
        break
    temp = (a[ptr1] * a[ptr2]) % mod
    a[ptr1] = 1
    a[ptr2] = temp
    ptr1 -= 1

result = sum(a) % mod
print(result)
  • Java
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[] input = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int n = input[0], m = input[1];
        long[] a = Arrays.stream(scanner.nextLine().split(" ")).mapToLong(Long::parseLong).toArray();
        long mod = (long) (1e9 + 7);
        
        Arrays.sort(a);
        int ptr1 = n - 2, ptr2 = n - 1;
        
        for (int i = 0; i < m && ptr1 >= 0; i++) {
            long temp = (a[ptr1] * a[ptr2]) % mod;
            a[ptr1] = 1;
            a[ptr2] = temp;
            ptr1--;
        }
        
        long result = 0;
        for (long num : a) {
            result = (result + num) % mod;
        }
        System.out.println(result);
    }
}
  • Cpp
#include <iostream>
#include <algorithm>
using namespace std;

const int mod = 1e9 + 7;

int main() {
    int n, m;
    cin >> n >> m;
    long long a[n];
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    
    sort(a, a + n);
    int ptr1 = n - 2, ptr2 = n - 1;
    
    for (int i = 0; i < m && ptr1 >= 0; i++) {
        long long temp = (a[ptr1] * a[ptr2]) % mod;
        a[ptr1] = 1;
        a[ptr2] = temp;
        ptr1--;
    }
    
    long long result = 0;
    for (int i = 0; i < n; i++) {
        result = (result + a[i]) % mod;
    }
    cout << result << endl;
    
    return 0;
}

04.K小姐的礼物盒

问题描述

K小姐有两个礼物盒,每个礼物盒中都装有 n n n 个礼物。第一个礼物盒中的礼物价值分别为 a 1 , a 2 , … , a n a_1, a_2, \dots, a_n a1,a2,,an,第二个礼物盒中的礼物价值分别为 b 1 , b 2 , … , b n b_1, b_2, \dots, b_n b1,b2,,bn

K小姐想要重新排列两个礼物盒中的礼物,使得对于每个 i ∈ [ 1 , n ] i \in [1, n] i[1,n],第一个礼物盒中第 i i i 个位置的礼物价值 a i a_i ai 与第二个礼物盒中第 i i i 个位置的礼物价值 b i b_i bi 之和都满足 1 ≤ a i + b i ≤ m 1 \leq a_i + b_i \leq m 1ai+bim

现在给定 q q q 组询问,每组询问给定两个礼物盒的初始状态,请判断是否存在一种重排方案满足K小姐的要求。

输入格式

第一行输入一个整数 q q q ( 1 ≤ q ≤ 30 ) (1 \leq q \leq 30) (1q30),表示询问的组数。

接下来 q q q 组询问,每组询问格式如下:

第一行两个整数 n n n ( 1 ≤ n ≤ 500 ) (1 \leq n \leq 500) (1n500) m m m ( 1 ≤ m ≤ 500 ) (1 \leq m \leq 500) (1m500),分别表示礼物的数量和价值和的上限。

第二行 n n n 个整数 a 1 , a 2 , … , a n a_1, a_2, \dots, a_n a1,a2,,an,表示第一个礼物盒中的礼物价值。

第三行 n n n 个整数 b 1 , b 2 , … , b n b_1, b_2, \dots, b_n b1,b2,,bn,表示第二个礼物盒中的礼物价值。

其中, − 500 ≤ a i , b i ≤ 500 -500 \leq a_i, b_i \leq 500 500ai,bi500

输出格式

输出 q q q 行,每行对应一组询问的答案。如果存在满足条件的重排方案,输出 Yes,否则输出 No

样例输入

2
5 3
-1 -2 3 4 5
-1 3 4 2 5
5 6
-1 -2 3 4 5
-1 3 4 2 5

样例输出

No
Yes

数据范围

  • 1 ≤ q ≤ 30 1 \leq q \leq 30 1q30
  • 1 ≤ n ≤ 500 1 \leq n \leq 500 1n500
  • 1 ≤ m ≤ 500 1 \leq m \leq 500 1m500
  • − 500 ≤ a i , b i ≤ 500 -500 \leq a_i, b_i \leq 500 500ai,bi500

题解

本题可以使用贪心的思想来解决。对于每组询问,我们可以将两个礼物盒中的礼物分别按照价值进行排序,然后考虑将第一个礼物盒中价值最小的礼物与第二个礼物盒中价值最大的礼物配对,依次类推。

对于排序后的两个礼物盒,我们从左右两端开始配对,即第一个礼物盒中的第 i i i 个礼物与第二个礼物盒中的第 n − i + 1 n-i+1 ni+1 个礼物配对。如果对于每一对配对的礼物,它们的价值和都满足 1 ≤ a i + b n − i + 1 ≤ m 1 \leq a_i + b_{n-i+1} \leq m 1ai+bni+1m,那么就存在满足条件的重排方案;否则,不存在满足条件的重排方案。

时间复杂度:对于每组询问,排序的时间复杂度为 O ( n log ⁡ n ) O(n \log n) O(nlogn),配对检查的时间复杂度为 O ( n ) O(n) O(n),总时间复杂度为 O ( q × ( n log ⁡ n + n ) ) O(q \times (n \log n + n)) O(q×(nlogn+n))
空间复杂度: O ( n ) O(n) O(n),用于存储礼物盒中的礼物价值。

参考代码

  • Python
q = int(input())

for _ in range(q):
    n, m = map(int, input().split())
    a = list(map(int, input().split()))
    b = list(map(int, input().split()))
    
    a.sort()
    b.sort(reverse=True)
    
    flag = True
    for i in range(n):
        if not (1 <= a[i] + b[i] <= m):
            flag = False
            break
    
    print("Yes" if flag else "No")
  • Java
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int q = sc.nextInt();
        
        while (q-- > 0) {
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[] a = new int[n];
            int[] b = new int[n];
            
            for (int i = 0; i < n; i++) {
                a[i] = sc.nextInt();
            }
            for (int i = 0; i < n; i++) {
                b[i] = sc.nextInt();
            }
            
            Arrays.sort(a);
            Arrays.sort(b);
            reverse(b);
            
            boolean flag = true;
            for (int i = 0; i < n; i++) {
                if (a[i] + b[i] < 1 || a[i] + b[i] > m) {
                    flag = false;
                    break;
                }
            }
            
            System.out.println(flag ? "Yes" : "No");
        }
    }
    
    private static void reverse(int[] arr) {
        int left = 0, right = arr.length - 1;
        while (left < right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}
  • Cpp
#include <iostream>
#include <algorithm>
using namespace std;

const int MAX_N = 500;

int main() {
    int q;
    cin >> q;
    
    while (q--) {
        int n, m;
        cin >> n >> m;
        int a[MAX_N], b[MAX_N];
        
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        for (int i = 0; i < n; i++) {
            cin >> b[i];
        }
        
        sort(a, a + n);
        sort(b, b + n, greater<int>());
        
        bool flag = true;
        for (int i = 0; i < n; i++) {
            if (a[i] + b[i] < 1 || a[i] + b[i] > m) {
                flag = false;
                break;
            }
        }
        
        cout << (flag ? "Yes" : "No") << endl;
    }
    
    return 0;
}

05.LYA 的平均分目标

问题描述

LYA 是一名刚入学的大学新生,她的专业课程有 n n n 门。在大一第一学期结束时,她的任课老师给每门课程都打了分数。这 n n n 个分数构成了一个数组 a 1 , a 2 , … , a n a_1, a_2, \ldots, a_n a1,a2,,an

作为一名学霸,LYA 希望自己的平均分能达到 k k k 分。为此,她想从这 n n n 门课程中选出一些连续的课程,使得这些课程的平均分恰好等于 k k k。现在,她想知道最多可以选出多少门课程。

输入格式

第一行包含两个正整数 n n n k k k,分别表示课程总数和目标平均分。

第二行包含 n n n 个正整数 a 1 , a 2 , … , a n a_1, a_2, \ldots, a_n a1,a2,,an,表示每门课程的分数。

输出格式

输出一个整数,表示 LYA 最多可以选出的满足条件的连续课程数量。

样例输入

5 2
1 3 2 4 1

样例输出

3

数据范围

  • 1 ≤ n ≤ 1 0 5 1 \le n \le 10^5 1n105
  • 1 ≤ k , a i ≤ 1 0 9 1 \le k, a_i \le 10^9 1k,ai109

题解

本题可以使用前缀和 + 哈希表的方法来解决。

首先,我们可以计算出数组 a a a 的前缀和数组 s u m sum sum,其中 s u m [ i ] sum[i] sum[i] 表示前 i i i 个元素的和。为了方便计算,我们可以在数组 s u m sum sum 的开头添加一个元素 0 0 0,即 s u m [ 0 ] = 0 sum[0] = 0 sum[0]=0

接下来,我们遍历前缀和数组 s u m sum sum,对于每个位置 i i i,我们计算 s u m [ i ] − i × k sum[i] - i \times k sum[i]i×k。如果当前值出现过,说明存在一个子数组,其元素和为 i × k i \times k i×k,平均值为 k k k。我们可以用哈希表来记录每个值第一次出现的位置,从而快速判断当前值是否出现过。

最后,我们取出最长的满足条件的子数组长度即可。

时间复杂度为 O ( n ) O(n) O(n),空间复杂度为 O ( n ) O(n) O(n)

参考代码

  • Python
n, k = map(int, input().split())
a = list(map(int, input().split()))

s = [0] * (n + 1)
for i in range(1, n + 1):
    s[i] = s[i - 1] + a[i - 1] - k

pos = {0: 0}
ans = 0
for i in range(1, n + 1):
    if s[i] in pos:
        ans = max(ans, i - pos[s[i]])
    else:
        pos[s[i]] = i

print(ans)
  • Java
import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] line = br.readLine().split(" ");
        int n = Integer.parseInt(line[0]);
        long k = Long.parseLong(line[1]);
        
        long[] a = new long[n];
        line = br.readLine().split(" ");
        for (int i = 0; i < n; i++) {
            a[i] = Long.parseLong(line[i]);
        }
        
        long[] s = new long[n + 1];
        for (int i = 1; i <= n; i++) {
            s[i] = s[i - 1] + a[i - 1] - k;
        }
        
        Map<Long, Integer> pos = new HashMap<>();
        pos.put(0L, 0);
        int ans = 0;
        for (int i = 1; i <= n; i++) {
            if (pos.containsKey(s[i])) {
                ans = Math.max(ans, i - pos.get(s[i]));
            } else {
                pos.put(s[i], i);
            }
        }
        
        System.out.println(ans);
    }
}
  • Cpp
#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

int main() {
    int n;
    long long k;
    cin >> n >> k;
    
    vector<long long> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
    
    vector<long long> s(n + 1);
    for (int i = 1; i <= n; i++) {
        s[i] = s[i - 1] + a[i - 1] - k;
    }
    
    unordered_map<long long, int> pos;
    pos[0] = 0;
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        if (pos.count(s[i])) {
            ans = max(ans, i - pos[s[i]]);
        } else {
            pos[s[i]] = i;
        }
    }
    
    cout << ans << endl;
    
    return 0;
}

写在最后

📧 KK这边最近正在收集近一年互联网各厂的笔试题汇总,如果有需要的小伙伴可以关注后私信一下 KK领取,会在飞书进行同步的跟新。

在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/519079.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

在线除背景抠图工具推荐,通过AI自动去除人物背景,给图片背景换色

发现了一个好的在线除水印的网站&#xff0c;这里由「易极赞」的小编来分享给大家。它就是我们今天的主角SnapEdit。 工具简介 SnapEdit 借助至极先进的人工智能技术&#xff0c;得以自动判别图像的主体与背景&#xff0c;飞速地移除背景且保留主体的细微之处和边缘轮廓&…

十六.PyEcharts常用视图(2)

目录 一.饼图 二.空心饼图(掏空) 三.玫瑰图 四.修改图例位置--全局 五.雷达图 六.时间轴 简单写一下,快速出图... 一.饼图 #饼图 import pyecharts.options as opts from pyecharts.faker import Faker from pyecharts.charts import Pie #zip() data_pie list(zip(Fa…

Floyd之蓝桥公园

Floyd Floyd算法是一种用于解决“所有点最短路径”问题的算法。这是一个动态规划算法&#xff0c;可以在任何包含向量和非负权重的图中使用。它的时间复杂度是&#xff0c;其中是图中的节点数。 首先&#xff0c;我们定义一个二维数组表示从到的最短距离&#xff0c;初始时如…

软著说明文档生成/辅助填写工具

软著说明文档生成/辅助填写工具&#xff0c;自行申请软著的话&#xff0c;软著60页源码还比较容易搞定&#xff0c;但是说明文档有格式和字数要求&#xff0c;就很烦。这个网站可以进行格式和内容的辅助填写&#xff0c;不用再把精力浪费到没用的调整格式上&#xff0c;网站地址…

揭秘SCQL:隐私计算的未来之路

1.SCQL使用/集成最佳实践 隐语隐私计算中SCQL&#xff08;Secure Collaborative Query Language&#xff09;的设计旨在提供一种便捷且安全的方式来处理多方参与下的隐私敏感数据查询与分析&#xff0c;而无需暴露原始数据给任何一方。以下是基于以上所记录信息的SCQL使用和集…

Jackson @JsonUnwrapped注解扁平化 序列化反序列化数据

参考资料 Jackson 2.x 系列【7】注解大全篇三JsonUnwrapped 以扁平的数据结构序列化/反序列化属性Jackson扁平化处理对象 目录 一. 前期准备1.1 前端1.2 实体类1.3 Controller层 二. 扁平化序列反序列化数据2.1 序列化数据2.2 反序列化数据 三. 前缀后缀处理属性同名四. Map数…

Pillow教程10:设计博文的文字背景封面图,再也不担心找不到不素材了

---------------Pillow教程集合--------------- Python项目18&#xff1a;使用Pillow模块&#xff0c;随机生成4位数的图片验证码 Python教程93&#xff1a;初识Pillow模块&#xff08;创建Image对象查看属性图片的保存与缩放&#xff09; Pillow教程02&#xff1a;图片的裁…

C#中ref和out相关知识点

知识点一&#xff1a; 知识点二&#xff1a; 知识点三&#xff1a; 测试&#xff1a; 总结&#xff1a; 练习

逐步学习Go-WaitGroup【连字都懒得写了,直接Show my Code】

package waitgroup_testimport ("fmt""runtime""sync""testing""time""github.com/stretchr/testify/assert" )// 这是对Go语标准库中sync包下的WaitGroup的描述。// WaitGroup用于等待一组并发的goroutine结结束…

理解VAE,可视化

引言 本文主要摘抄自&#xff1a;Understanding Variational Autoencoders (VAEs), Joseph Rocca, Sep 24, 2019&#xff0c;同时会加一些自己的理解和对原文的解释。 关于数据生成&#xff0c;目前深度生成模型中主流的有&#xff1a; 生成对抗网络——GANs&#xff0c;这是…

【Python的第三方库】flask

1. Flask是什么&#xff1f; 基于python的web后端开发轻量级框架&#xff1b; 基于MVT设计模式即Models,Views,Templates(html模板语言) 2.中文文档&#xff1a; https://dormousehole.readthedocs.io/en/2.1.2/index.html 3.依赖3个库&#xff1a; Jinja2 模版&#xff1…

armlinux-外部中断

s3c2440的中断框图 如果我们单纯配置一个按键的外部中断&#xff0c;就不存在子中断与优先级的问题。 由于是按键的外部中断&#xff0c;通过引脚的高低电平来触发。所以我们要先配置引脚的功能。 我们使用按键1&#xff0c;终端源为EINT8&#xff0c;对应引脚GPG0 通过用户手…

物联网实战--入门篇之(八)嵌入式-空气净化器

目录 一、风扇调速 二、通讯协议 三、净化器运行逻辑 一、风扇调速 单片机是不能直接驱动电机的&#xff0c;因为主芯片的驱动电流比较小(50mA左右)&#xff0c;他们之间正常还要有个电机驱动器&#xff0c;常用的有TB6612、L298和L9110等&#xff0c;目前项目用的这个电机它…

全国航空机场分布矢量数据/旅游景点poi/全国港口码头分布/地铁站分布/火车站分布/POI矢量数据

民用航空机场是指针对包括跑道型机场、表面直升机场、高架直升机场、船上直升机场、直升机水上平台、滑翔机场、水上机场、有人操纵气球施放场以及其他专供民用航空器起降的划定区域。民用航空机场分为通用航空机场和公共运输机场&#xff1b;不包括临时机场和专用机场。 根据中…

谷歌修复了安卓中的 28 个漏洞和 Pixel 设备中的 25 个错误

关注公众号&#xff1a; 网络研究观 获取更多信息 本周&#xff0c;谷歌工程师修复了Android 中的 28 个漏洞和 Pixel 设备中的 25 个错误&#xff0c;其中包括两个已经被利用的问题。 据报道&#xff0c;网络取证已利用 Google Pixel 0day 漏洞在没有 PIN 码的情况下解锁智能…

【附下载】2024全行业数字化转型企业建设解决方案PPT合集

精品推荐&#xff0c;2024全行业数字化转型企业建设解决方案PPT合集&#xff0c;精品PPT源格式共21份。 以下是资料目录&#xff0c;如需下载&#xff0c;请前往星球获取&#xff1a; 1.制造业数字化转型解决方案及应用.pptx 2.医院数字化网络解决方案.pptx 3.食品饮料工厂数字…

Vuex(vue 项目中实现 频繁、大范围数据共享的技术方案)

参考文档(点击查看) 好处 1.数据的存取一步到位&#xff0c;不需层层传递 2.数据的流动非常清晰 3.存储在Vuex中的数据都是响应式的&#xff08;数据更新后&#xff0c;使用数据的组件都会自动更新&#xff09; Vuex基础配置 npm i vuex3.6.2state中用来存储数据&#xff0c…

js中使let关键字报错,改用var关键字解决

js中使let关键字报错,改用var关键字解决 项目场景&#xff1a;问题描述原因分析&#xff1a;解决方案&#xff1a;总结 项目场景&#xff1a; 使用 let 关键字报错&#xff0c;报错信息为&#xff1a; Uncaught ReferenceError: maxNum is not defined at getMaxNum (4-3.htm…

专题三——二分算法

目录 原理 模板 朴素二分算法 非朴素二分算法 一二分查找 二在排序数组中查找元素的第一个和最后一个位置 三点名 四x的平方根 五搜索插入位置 六山脉数组的峰顶索引 七寻找峰值 八寻找旋转排序数组中的最小值 原理 定义两个指针&#xff1a;left指向数组第一个元…

Layui三级联动插件使用方法

Layui高版本中没有在提供三级联动这个动画了&#xff0c;而是封装成了一个插件&#xff0c;使用方式也很简单 官网 省市县区三级联动下拉选择器 layarea - Layui 第三方扩展组件平台 (layuion.com)https://dev.layuion.com/extend/layarea/#doc html页面约束 整个选择器需要…