2024华为OD笔试机试 - 数字游戏 (Java/c++/python D卷C卷真题算法)

华为OD机试（C卷+D卷）2024真题目录(Java & c++ & python)

题目描述

小明玩一个游戏。

系统发1+n张牌，每张牌上有一个整数。

第一张给小明，后n张按照发牌顺序排成连续的一行。

需要小明判断，后n张牌中，是否存在连续的若干张牌，其和可以整除小明手中牌上的数字。

输入描述

输入数据有多组，每组输入数据有两行，输入到文件结尾结束。

第一行有两个整数n和m，空格隔开。m代表发给小明牌上的数字。

第二行有n个数，代表后续发的n张牌上的数字，以空格隔开。

输出描述

对每组输入，如果存在满足条件的连续若干张牌，则输出1;否则，输出0

备注

• 1 ≤ n ≤ 1000
• 1 ≤ 牌上的整数 ≤ 400000
• 输入的组数，不多于1000
• 用例确保输入都正确，不需要考虑非法情况。

用例

输入

6 7
2 12 6 3 5 5
10 11
1 1 1 1 1 1 1 1 1 1

输出

1
0

说明 两组输入。第一组小明牌的数字为7，再发了6张牌。第1、2两张牌教字和为14，可以整除7，输出1，第二组小明牌的教字为11，再发了10张牌，这10张牌数字和为10，无法整除11，输出0。

解题思路

前缀和+简单数学。
要求连续若干张牌的和，其实就是求区间的元素之和。
而求解任意区间和的O(1)算法就是：前缀和之差

[L,R]区间和 = preSum[R] - preSum[L-1]

• 如果两个数a,b，他们的差a - b可以被k整除，则必然 a % k == b % k。

• 反之，如果a % k == b % k，那么 a - b 必然可以被k整除。

所以只需要对前缀和数组逐个对k取模，如果preSum[L] == preSum[R]，则说明区间[L+1, R]的区间和可以被k整除。

所以只需要判断取模后是否有相同数值即可得出结果。

• 扩展：如果是求符合条件的有多少种情况？
• 可以用一个大小为k的计数数组，因为相同数值两两都可以符合，细节可以自己动手琢磨，有不明白可以评论区或私信。

C++、Java、Python代码如下：

C++参考代码

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

int isExist(const vector<int>& nums, int m) {
    unordered_set<int> remain;
    remain.insert(0); // 初始化余数集合，包含0

    int sum = 0; // 初始化累计和
    for (int num : nums) {
        sum += num; // 累加当前数字
        
        // 如果当前累计和的余数在集合中已经存在，则说明存在子数组的和为m的倍数
        if (remain.find(sum % m) != remain.end()) {
            return 1; // 存在，返回1
        } else {
            remain.insert(sum % m); // 否则，将当前余数添加到集合中
        }
    }

    return 0; // 不存在，返回0
}

int main() {
    string line;
    
    // 读取输入
    while (getline(cin, line)) {
        vector<int> tmp, nums;
        int n, m;
        
        // 第一行输入
        stringstream ss1(line);
        int val;
        while (ss1 >> val) {
            tmp.push_back(val);
        }
        n = tmp[0];
        m = tmp[1];
        
        // 第二行输入
        if (!getline(cin, line)) break;
        stringstream ss2(line);
        while (ss2 >> val) {
            nums.push_back(val);
        }

        // 判断是否存在子数组之和为m的倍数
        cout << isExist(nums, m) << endl;
    }
    
    return 0;
}

Java参考代码

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

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

    // 读取输入的两行数据
    while (sc.hasNextLine()) {
      try {
        // 第一行输入，获取数组的大小和目标值m
        int[] tmp = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        
        // 第二行输入，获取具体的数组元素
        int[] nums = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        
        // 判断是否存在子数组之和为m的倍数
        System.out.println(isExist(nums, tmp[1]));
      } catch (Exception e) {
        break; // 如果出现异常，则退出循环
      }
    }
  }

  public static int isExist(int[] nums, int m) {
    HashSet<Integer> remain = new HashSet<>();
    remain.add(0); // 初始化余数集合，包含0

    int sum = 0; // 初始化累计和
    for (int num : nums) {
      sum += num; // 累加当前数字
      
      // 如果当前累计和的余数在集合中已经存在，则说明存在子数组的和为m的倍数
      if (remain.contains(sum % m)) {
        return 1; // 存在，返回1
      } else {
        remain.add(sum % m); // 否则，将当前余数添加到集合中
      }
    }

    return 0; // 不存在，返回0
  }
}

Python参考代码

def hasSubarrayWithSumDivisible(nums, m):
    # 记录余数
    remainders = set()
    remainders.add(0)
    
    total = 0
    for num in nums:
        total += num
        remainder = total % m
        if remainder in remainders:
            return 1
        remainders.add(remainder)
    
    return 0

# 输入获取与处理
while True:
    try:
        n, m = map(int, input().split())
        nums = list(map(int, input().split()))
        print(hasSubarrayWithSumDivisible(nums, m))
    except ValueError:
        break