该算法的比特成本时间复杂度是多少（Java 示例）？

Question

我编写了以下 Java 代码，用于使用分而治之的方法计算在位向量中找到的 1:s 的数量。我试图找出算法“count”的时间复杂度，假设我们有一个函数IsZero(int []arr, int low, int high)（可能不切实际）在 O(1) 中运行，如果 low之间的所有位都返回 true > 和 high 为 0。我将包含一个主要方法来解释如何使用该算法，以及我自己的 IsZero 实现（它不会以 O(1) 复杂度运行）。所以，问题是。考虑到 IsZero 的复杂度为 O(1)，这个算法的时间复杂度是多少？

Class Algorithm {

   static int NumberOfOnes(int v[]) {
       return count(v, 0, v.length-1);
   }

   static boolean IsZero(int arr[], int low, int high){
     for(int i = low; i <= high; i++){
         if(arr[i] == 1){
            return false;
         }
     }
     return true;
   }

   static int count(int arr[], int low, int high){

         if (low == high && arr[low] == 1) {
             return 1;
         }
         
         if (high - low == 1) {
             return arr[low] + arr[high];
         }

         if(IsZero(arr, low, high)) {
             return 0;
         }

         int mid = (low + high) / 2;
         return count(arr, low, mid) + count(arr, mid + 1, high);
   }

   public static void main(String args[]) {
       int arr[] = {1,1,0,0,0,0,1,0,1,1};
       int k = NumberOfOnes(arr);
       System.out.println(k); //Should print 5 as result
   }

}

Answer 1

复杂度为 O(1+k*log(n))

与分而治之的算法一样，您可以通过将问题一分为二并分别解决这两个部分来解决更大的问题。这为您提供log(n)“层”，其中每个后续层的子问题是前一层的两倍。但是，我们可以直接丢弃一些层（如果它们没有层），这意味着在任何时候我们最多处理 k 个子问题。对于每个子问题，我们调用一次 IsZero，因此我们最多做 k 个“事情”，总共 log(n) 次，这导致 O(1+k*log(n))。请注意，如果 k=0，则添加 1。

但更严格的界限是 O(1 + min(n, k*log(n)))

与其他常见的 D&C 算法（例如 MergeSort）不同，您实际上在每一层都没有线性步长。这意味着在最坏的情况下（不能丢弃任何子问题），您在第一层最多做 1 个“事情”，在第二层最多做 2 个“事情”，然后是 4、8、16 等等，直到你做 n最后一层的“东西”。这个总和等于2n-1，当然是O(n)。

因此O(n) 和O(1+k*log(n)) 都是正确的，因此更严格的界限是O(1 + min(n, k*log(n)))。

当然，您可以在 O(n) 中执行此操作并不令人惊讶，因为简单的解决方案在 O(n) 中，但我发现它是您算法的一个相当简洁的属性。