【华为OD机试真题】1、滑动窗口最大值 | 机试真题+思路参考+代码解析（C语言、C++、Java、Py、JS）

---

🍂个人博客首页： KJ.JK
 
🍂专栏介绍： 华为OD机试真题汇总，定期更新华为OD各个时间阶段的机试真题，每日定时更新，本专栏将使用C语言、C++、Java、Python、JS语言进行更新解答，包含真题，思路分析，代码参考，欢迎大家订阅学习

---

一、题目

---

🎃题目描述

有一个N个整数的数组，和一个长度为M的窗口，窗口从数组内的第一个数开始滑动直到窗口不能滑动为止，
 
每次窗口滑动产生一个窗口和（窗口内所有数的和），求窗口滑动产生的所有窗口和的最大值

---

🎃输入输出

输入
第一行输入一个正整数N，表示整数个数。（0<N<100000）
第二行输入N个整数，整数的取值范围为[-100,100]。
第三行输入一个正整数M，M代表窗口的大小，M<=100000，且M<=N。
 
输出
窗口滑动产生所有窗口和的最大值

---

🎃样例1

输入
6
12 10 20 30 15 23
3


输出
68

说明

窗口长度为3，窗口滑动产生的窗口和分别为10+20+30=60，20+30+15=65，30+15+23=68，15+23+12=50，

所以窗口滑动产生的所有窗口和的最大值为68

---

二、代码与思路参考

---

🎈C语言思路

---

1、首先，读取输入的整数个数N和整数数组，以及窗口大小M

2、定义一个变量maxSum，用于记录窗口滑动产生的所有窗口和的最大值，初始值为负无穷大

3、计算初始窗口的和sum，即前M个数的和

4、遍历数组从第M个数开始，每次滑动窗口：

• 将窗口的第一个数移出窗口，即从sum中减去窗口的第一个数，
• 将窗口的下一个数添加到窗口中，即将窗口的下一个数加到sum中，更新maxSum，
• 如果sum大于maxSum，则更新maxSum为sum

5、输出maxSum作为结果

---

🎉C代码

#include <stdio.h>

int main() {
    int N;
    scanf("%d", &N);
    int arr[N];
    for (int i = 0; i < N; i++) {
        scanf("%d", &arr[i]);
    }

    int M;
    scanf("%d", &M);

    int maxSum = -100000; // 初始化为负无穷大
    int sum = 0;

    // 计算初始窗口的和
    for (int i = 0; i < M; i++) {
        sum += arr[i];
    }

    // 窗口滑动，计算所有窗口和的最大值
    for (int i = M; i <= N; i++) {
        if (sum > maxSum) {
            maxSum = sum;
        }

        // 窗口滑动：移出窗口的第一个数，加入窗口的下一个数
        sum -= arr[i - M];
        sum += arr[i];
    }

    printf("%d\n", maxSum);

    return 0;
}

---

🎈C++语言思路

---

1、读取输入的整数N，表示数组的长度

2、读取输入的整数数组元素，将其存储在一个名为arr的向量中

3、读取输入的整数M，表示滑动窗口的长度

4、初始化变量window_sum为前M个元素的和，即窗口的初始和

5、初始化变量max_sum为window_sum，表示当前的最大和

6、从M开始，通过遍历数组来移动滑动窗口

• 在每个位置i，通过将窗口最左边的元素移出窗口并将窗口最右边的元素移入窗口，更新window_sum的值
• 检查window_sum是否大于max_sum，如果是，则将max_sum更新为window_sum

7、遍历完成后，max_sum将包含滑动窗口的最大和

8、输出max_sum作为结果

---

🎉C++代码

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int N;
    cin >> N; // 输入N
    
    vector<int> arr(N);
    for (int i = 0; i < N; i++) {
        cin >> arr[i]; // 输入数组元素
    }
    
    int M;
    cin >> M; // 输入M
    
    int window_sum = 0;
    for (int i = 0; i < M; i++) {
        window_sum += arr[i]; // 计算初始窗口和
    }
    
    int max_sum = window_sum; // 初始化最大和为初始窗口和
    
    for (int i = M; i < N; i++) {
        window_sum = window_sum - arr[i - M] + arr[i]; // 更新窗口和，减去窗口最左边的元素，加上窗口最右边的元素
        max_sum = max(max_sum, window_sum); // 更新最大和
    }
    
    cout << max_sum << endl; // 输出最大和
    
    return 0;
}

---

🎈Java语言思路

---

1、首先，从输入中获取数组的长度 N，并创建一个大小为 N 的整数数组 arr

2、使用循环，将输入的 N 个整数依次存储到数组 arr 中

3、获取窗口大小 M

4、初始化一个变量 windowSum 为 0，用于存储当前窗口内元素的和

5、使用一个循环，计算初始窗口大小为 M 的子数组的和，并将结果存储在 windowSum 变量中

6、将 windowSum 的值赋给变量 maxSum，作为初始的最大窗口和

7、使用另一个循环，从第 M 个元素开始，不断移动滑动窗口。在每次迭代中，更新窗口和 windowSum，通过减去窗口最左端的元素并加上窗口最右端的元素。然后，使用 Math.max 方法将 windowSum 和 maxSum 的较大值更新到 maxSum 变量中

8、循环结束后，maxSum 中存储的就是整个数组中连续子数组的和的最大值

9、最后，输出 maxSum 的值，即最大窗口和

---

🎉Java代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();  // 输入数组的长度
        int[] arr = new int[N];
        for (int i = 0; i < N; i++) {
            arr[i] = scanner.nextInt();  // 输入数组元素
        }
        int M = scanner.nextInt();  // 窗口大小

        int windowSum = 0;  // 窗口内元素的和
        for (int i = 0; i < M; i++) {
            windowSum += arr[i];  // 计算初始窗口和
        }
        int maxSum = windowSum;  // 初始最大窗口和

        for (int i = M; i < N; i++) {
            windowSum = windowSum - arr[i - M] + arr[i];  // 更新窗口和
            maxSum = Math.max(maxSum, windowSum);  // 更新最大窗口和
        }

        System.out.println(maxSum);  // 输出结果
    }
}

---

🎈Python语言思路

---

给定一个长度为N的数组和窗口大小M，我们需要找到滑动窗口产生的所有窗口和的最大值。

我们可以使用滑动窗口的技巧来解决这个问题。首先，我们计算数组的前M个元素的和，作为初始窗口和的值。然后，我们从第M+1个元素开始，每次向右移动一个位置，同时更新窗口和的值。

具体步骤如下：

1、输入数组的长度N和数组元素

2、输入窗口大小M

3、计算初始窗口和的值，即数组的前M个元素的和

4、初始化一个变量max_sum为初始窗口和的值

5、从第M+1个元素开始，进行以下循环：

   窗口和的值减去滑出窗口的第一个元素，加上滑入窗口的下一个元素，更新窗口和的值
   如果当前窗口和的值大于max_sum，则更新max_sum为当前窗口和的值

6、输出max_sum作为结果

---

🎉Python代码

N = int(input())
arr = list(map(int, input().split()))
M = int(input())

window_sum = sum(arr[:M])
max_sum = window_sum

for i in range(M, N):
    window_sum = window_sum - arr[i - M] + arr[i]
    max_sum = max(max_sum, window_sum)

print(max_sum)

---

🎈JS语言思路

---

1、首先，通过 readline 模块创建一个接口，用于从命令行获取用户输入。

2、然后，从用户输入中获取 N（数组长度），并将其转换为整数。

3、接下来，从用户输入中获取数组元素，并将其转换为一个数组（arr）。

4、再然后，从用户输入中获取 M（窗口大小），并将其转换为整数。

5、接下来，定义一个变量 window_sum，用于保存当前窗口的和。将其初始化为数组中前 M 个元素的和。

6、然后，定义一个变量 max_sum，用于保存最大和的值。将其初始化为 window_sum。

7、接下来，使用一个循环从 M 开始遍历数组，每次循环时，窗口右移一位。在右移时，从 window_sum 中减去窗口左边的元素，并加上窗口右边的元素。然后，比较 window_sum 和 max_sum 的值，取较大的值作为最大和。

8、最后，打印出最大和的值，并关闭 readline 接口。

---

🎉JS代码

const readline = require('readline');
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

let N, arr, M;

rl.question("Enter N: ", (n) => {
  N = parseInt(n);
  rl.question("Enter array elements: ", (elements) => {
    arr = elements.split(' ').map(Number);
    rl.question("Enter M: ", (m) => {
      M = parseInt(m);
      
      // 计算初始窗口的和
      let window_sum = arr.slice(0, M).reduce((a, b) => a + b, 0);
      let max_sum = window_sum;

      for (let i = M; i < N; i++) {
        // 窗口右移时，减去左边元素，加上右边元素
        window_sum = window_sum - arr[i - M] + arr[i];
        max_sum = Math.max(max_sum, window_sum);
      }

      console.log(max_sum);
      rl.close();
    });
  });
});

作者：KJ.JK