如何用python确定最长的子数组的长度

问题陈述

给定一个n维的整数数组。 阵列[].

任务是确定最长的子数组的长度，其总和等于提供的值 K.

样本输入

[1, 2, 3, 4, 0]      

样本输出

3

解释

和为7的最长子数是[3, 4, 0] 。

蛮力方法

考虑所有子数的总和，并返回最长的子数的长度与总和。 K.

时间复杂度为O(n2)。

高效的方法

设置 sum 为0， maxLen 为0。

制作一个哈希表，其中包含sum作为键，索引的向量作为值。

对i=0到 n-1执行以下步骤 。

将 arr[i]相加，得到总数。

如果总和等于 K，则设置 maxLen 为i+1。

检查是否 sum-K 是否包含在哈希表中。

如果存在，那么就遍历各自的向量，并不断 用子数组的最大长度更新 maxLen 。

将当前的总和插入到地图中。

一个优化

你可以创建一对(sum,i) 来代替存储索引的向量，其中 i 将存储具有给定sum的最早的索引。只有在地图中不存在的情况下才将sum作为键插入。

让我们来看看这些方法。

C++

#include<bits/stdc++.h>
using namespace std;
int lenOfLongSubarr(int a[],  int N, int K)
	{
    	long long int sum=0;
    	int ans=0;
    	

Python

def findLongestSubarray(arr, n, k):

    my_dictionary = dict()

    # Initialize sum and maxLen with 0
    sum = 0
    maxLen = 0

    # traverse the given array
    for i in range(n):

   	 # accumulate the sum
   	 sum += arr[i]

   	 # when subArray starts from index '0'
   	 if (sum == k):
   		 maxLen = i + 1

   	 elif (sum - k) in my_dictionary:
   		 maxLen = max(maxLen, i - my_dictionary[sum - k])

   	 if sum not in my_dictionary:
   		 my_dictionary[sum] = i

    return maxLen

l = [1, 2, 3, 4, 0]
K = 7
print(findLongestSubarray(l, 5, K))

C#

using System;
using System.Collections.Generic;

class Solution
{

static int longestSubarray(int[] arr, int n, int k)
{
    Dictionary<int, int> map_sum = new Dictionary<int,int>();
    int sum = 0, maxLen = 0;

    // traverse the array
    for (int i = 0; i < n; i++)
    {
   	 
   	 // accumulate sum
   	 sum += arr[i];
   	 
   	 if (sum == k)
   		 maxLen = i + 1;

   	 if (!map_sum.ContainsKey(sum))
   	 {
   		 map_sum.Add(sum, i);
   	 }

   	 // check if 'sum-k' is present in 'map_sum'
   	 if (map_sum.ContainsKey(sum - k))
   	 {
   		 // update maxLength
   		 if (maxLen < (i - map_sum[sum - k]))
   			 maxLen = i - map_sum[sum - k];
   	 }
    }
    
    return maxLen;   	 
}
public static void Main(String []args)
	{
    	int[] arr = {1, 2, 3, 4, 0};
    	int n = arr.Length;
    	int K = 7;
    	Console.WriteLine(longestSubarray(arr, n, K));

}
}