华为OD机试真题Java_2022-2023-题目0189-最多等和不相交连续子序列

AmosCloud2013

已于 2023-01-09 12:49:25 修改

阅读量879

点赞数 1

分类专栏： 2023-JavaC等六种语言华为OD机试真题文章标签： java 开发语言算法数据结构

于 2023-01-09 12:48:02 首次发布

本文链接：https://blog.csdn.net/amos_cloud/article/details/128612629

版权

2023-JavaC等六种语言华为OD机试真题专栏收录该内容

259 篇文章 216 订阅 ¥69.90 ¥99.00

订阅专栏

超级会员免费看

这道题目要求在给定的数组中找到最多数量的互不相交且和相等的连续子序列。输入包含数组长度N和N个整数。输出是最大的子序列组数。解决方案包括使用DP表记录连续子序列的和及出现次数，以找到最优解。时间复杂度为O(n^2)，空间复杂度为O(n)。

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

最多等和不相交连续子序列

题目描述

给定一个数组，我们称其中连续的元素为连续子序列，称这些元素的和为连续子序列的和。
数组中可能存在几组连续子序列，组内的连续子序列互不相交且有相同的和。
求一组连续子序列，组内子序列的数目最多。输出这个数目。

输入描述

第一行输入为数组长度 $\leq N \leq 10^3$ 。
第二行为 $N$ 个用空格分开的整数 $C_i，-10^5 \leq C_i \leq 10^5$ 。

输出描述

第一行是一个整数 $M$ ，表示满足要求的最多的组内子序列的数目。

示例一

输入

10
8 8 9 1 9 6 3 9 1 0

输出

说明

四个子序列第一个元素和最后一个元素下标分别为
2 2
4 4
5 6
7 7

示例一

输入

10
-1 0 4 -3 6 5 -6 5 -7 -3

输出

说明

三个子序列第一个元素和最后一个元素下标分别为
3 3
5 8
9 9

思路

这个题技巧性比较强，很容易进入误区写出复杂度很高的程序
以下解时间复杂度为 $O(n^2)$ ，空间复杂度为 $O (n)$

使用DP表避免重复计算，找到所有连续子序列，并求和
在所有和中，记录每个和出现的次数以及已经使用过的元素索引
每次如果对合法的和进行累加计数，则判断是否为出现最多的次数

详细见代码实现。

参考解题 Java

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * <br>Author: Amos
 * <br>E-mail: amos@amoscloud.com
 * <br>Date: 2023/1/9
 * <br>Time: 8:36
 * <br>Description:
 */
public class Main0189 {
  public static void main(String[] args) {
    try (Scanner scanner = new Scanner(System.in)) {
      int n = scanner.nextInt();
      scanner.nextLine();
      int[] seq = new int[n];
      for (int i = 0; i < n; i++) {
        seq[i] = scanner.nextInt();
      }
      int res = solution(seq, n);
      System.out.println(res);
    }
  }

  private static int solution(int[] seq, int n) {
    int max = 0;
    int[] dp = new int[n];
    System.arraycopy(seq, 0, dp, 0, n);
    Map<Integer, Integer> sumCount = new HashMap<>();
    Map<Integer, HashSet<Integer>> sumPos = new HashMap<>();
    for (int i = 0; i < n; i++) {
      for (int j = 0; j + i < n; j++) {
        if (i > 0) {
          dp[j] = dp[j] + seq[j + i];
        }
        int sum = dp[j];
        if (!sumCount.containsKey(sum)) {
          sumCount.put(sum, 0);
          sumPos.put(sum, new HashSet<>());
        }

        boolean exists = false;
        HashSet<Integer> poss = sumPos.get(sum);
        for (int k = j; k <= j + i; k++) {
          if (exists = poss.contains(k)) {
            break;
          }
        }
        if (!exists) {
          int newSum = sumCount.get(sum) + 1;
          sumCount.put(sum, newSum);
          max = Math.max(max, newSum);
          for (int k = j; k <= j + i; k++) {
            poss.add(k);
          }
          sumPos.put(sum, poss);
        }
      }
    }

    return max;
  }
}