Question

找到最长的子阵列，其总和可被K整除。有可能在O（n）？如果没有，那么可以更好地完成n ^ 2？

Answer 1

让s[i] = sum of first i elements modulo K。

我们有：

s[i] = (s[i - 1] + a[i]) % K

我们必须为每个i找到最小的j s[i] == s[j]。您可以通过散列s[i]值来找到它。如果K很小，您可以保留数组p[i] = first position for which s[k] == i。

复杂性为O(n)。

Answer 2

function longestRangeDividableBy(k) {
  arrayOfRanges
  sum =0
  startIndex = 0
  endIndex = 0
  for ( i=0 ; i < array.size; i++) {
    sum += array[i]
    if (sum % k != 0) {
      endindex = i
    } else {
      arrayOfRanges.add(new Range(startIndex, endIndex);
      startIndex = i+1
      sum = 0
    }
  }
  arrayOfRanges.sortDescending();
  return arrayOfRanges.get(0).lengthOfRange()
}

这里我说范围的搜索是线性的。因此，它取决于算法为O（n）或n ^ 2的排序。如果我错了，请纠正我。

Answer 3

如前面的答案所示，这可以在O（N）时间和空间内完成。其他答案提到散列和排序。但是，这个问题都不需要。在下面说明一次通过O（N）方法的python程序中，rr是输入数组，vb[x]是具有模块化值x的第一个子项的索引，ve[x] 1}}是模块值x的最后一个子索引。程序后显示典型输出。

import random
K, N, vmax = 10, 25, 99
rr = [random.randrange(vmax) for x in range(N)]
print 'rr', rr
vb, ve = [-1 for x in range(K)],  [-1 for x in range(K)]
vb[0] = ve[0] = mb = me = ms = s = 0

for i in range(N):
    s = (s + rr[i]) % K
    ve[s] = i+1
    if vb[s] < 0:
        vb[s] = i+1
    if ve[s] - vb[s] > me - mb:
        mb, me, ms = vb[s], ve[s], s

print "Max len is", me-mb, "for rem", ms, "at [", mb,":",me, "], total=", sum(rr[mb:me])

典型输出，K = 10且N = 25：

rr [26, 57, 0, 70, 33, 94, 23, 60, 62, 3, 28, 14, 12, 72, 6, 86, 29, 10, 60, 50, 21, 37, 40, 96, 73]
Max len is 21 for rem 3 at [ 2 : 23 ], total= 810

Answer 4

    as rightly pointed out by @IVIad you have to keep a track of the current 
sum modulo k. 
you can write it as s=0
          s=(s+arr1[i])%k 
    after that in a for loop you can use a dictionary and see if the 
s is present in dictionary ; 
if yes then update the length else update the dictionary .
    below is the code.


    def longestsubsarraywithsumdivisiblebyk(arr1,k):
        h={}
        h[0]=-1
        maxlen=0
        s=0
        for i in range(len(arr1)):
            s=(s+arr1[i])%k
            if s in h:
                maxlen=max(maxlen,i-h[s])
            else:
                h[s]=i
        return maxlen

找到最长的子阵列，其总和可被K整除

4 个答案: