算法的大O復雜度

Question

此方法試圖將num表示為arr中元素的乘積。

例如，method1（37，[1,3,5]）返回[2,0,7]

// arr is an array of divisors sorted in asc order, e.g. [1,3,5] 
def method1(num, arr) 
  newArr = Array.new(arr.size, 0)
  count = arr.size - 1

  while num > 0
    div = arr[count]  

    if div <= num
      arr[count] = num/div
      num = num % div
    end 

    count = count - 1
  end 

  return newArr
end 

如果您能給我一些幫助來推導算法的復雜性，將不勝感激。 也請隨時提高我的算法效率

Answer 1

這是代碼的重構版本：

def find_linear_combination(num, divisors)
  results = divisors.map do |divisor|
    q, num = num.divmod(divisor)
    q
  end
  results if num == 0
end

puts find_linear_combination(37, [5, 3, 1]) == [7, 0, 2]
puts find_linear_combination(37, [1, 3, 5]) == [37, 0, 0]
puts find_linear_combination(37, [5]).nil?

由於n是divisors的大小，該算法顯然看起來是O(n) 。 循環只有一個（ map ），循環內只有一個整數除法。

請注意，除數應按降序排列。 如果找不到線性組合，則該方法返回nil。

如果要對divisors進行排序，則算法為O(n*log n) 。 如有必要，最好追加1 （ O(1) ）。

Answer 2

您可以執行以下操作：

def method1(num, arr)

    newArr = Array.new(arr.size, 0)
    count = arr.size()-1

    while num>0
        div = arr[count]

        if div <= num
            arr[count] = num / div
            num = num % div
        end

        count = count + 1
    end
    return arr
end


ar = Array.new(25000000) { rand(1...10000) }

t1 = Time.now
method1(37, ar)
t2 = Time.now

tdelta = t2 - t1

print tdelta.to_f

輸出：

0.102611062

現在將數組大小增加一倍：

ar = Array.new(50000000) { rand(1...10) }

輸出：

0.325793964

並再次加倍：

ar = Array.new(100000000) { rand(1...10) }

輸出：

0.973402568

因此， n一倍，持續時間大約增加三倍。 由於O（3n）== O（n），因此整個算法將在O（n）時間內運行，其中n表示輸入數組的大小。