Question

我想知道如何降低此算法的时间复杂度。它计算最大子数组的长度，该子数组的元素总和为k整数。

a =整数数组

k =最大整数

例如：a = [1,2,3]，k = 3

可能的子阵列= [1]，[1,2]

最大子阵列的长度= 2

    sys.setrecursionlimit(20000)

    def  maxLength(a, k):
        #a = [1,2,3]
        #k = 4
        current_highest = 0
        no_bigger = len(a)-1
        for i in xrange(len(a)): #0 in [0,1,2]
            current_sum = a[i]
            sub_total = 1
            for j in xrange(len(a)):
                if current_sum <= k and ((i+sub_total)<=no_bigger) and (k>=(current_sum + a[i+sub_total])):
                    current_sum += a[i+sub_total]
                    sub_total += 1
                else:
                     break
            if sub_total > current_highest:
                current_highest = sub_total

        return current_highest

Answer 1

您可以使用FIRDatabase.database().reference().child("Ring1Fighting").observe(.value) { (snap: FIRDataSnapshot) in print((snap.value as! String)) }算法。

从sliding window开始，并在您前进时计算子阵列的总和。当sum超过index 0时，开始递减初始元素，直到sum再次小于k并再次开始求和。

在下面找到python代码：

输出：

def max_length(a,k):
    s = 0
    m_len = 0
    i,j=0,0
    l = len(a)
    while i<l:
        if s<=k and m_len<(j-i):
            m_len = j-i
        print i,j,s
        if s<=k and j<l:
            s+=a[j]
            j+=1
        else:
            s-=a[i]
            i+=1
    return m_len

a = [1,2,3]
k = 3
print max_length(a,k)

减少连续子阵列的时间复杂度

1 个答案: