Question

有人可以详细说明这个函数O（n ^ 2 * k）的时间复杂度如何？我理解while循环中的for循环将执行最多k次。但我不明白的是n ^ 2项。

void findSmallestRange(int arr[][N], int n, int k)
{
  int i,minval,maxval,minrange,minel,maxel,flag,minind;

  //initializing to 0 index;
  for(i = 0;i <= k;i++) 
    ptr[i] = 0;

  minrange = INT_MAX;

  while(1)       
  {
      // for mainting the index of list containing the minimum element
      minind = -1; 
      minval = INT_MAX;
      maxval = INT_MIN;
      flag = 0;

      //iterating over all the list
      for(i = 0;i < k;i++)   
      {    
          // if every element of list[i] is traversed then break the loop
          if(ptr[i] == n)   
          {
            flag = 1;
            break;
          }
          // find minimum value among all the list elements pointing by the ptr[] array 
          if(ptr[i] < n && arr[i][ptr[i]] < minval)  
          {
              minind=i;  // update the index of the list
              minval=arr[i][ptr[i]];
          }
          // find maximum value among all the list elements pointing by the ptr[] array
          if(ptr[i] < n && arr[i][ptr[i]] > maxval)    
          {
              maxval = arr[i][ptr[i]];
          }
      }

      //if any list exhaust we will not get any better answer ,so break the while loop
      if(flag) 
        break;

      ptr[minind]++;

      //updating the minrange
      if((maxval-minval) < minrange)  
      {
          minel = minval;
          maxel = maxval;
          minrange = maxel - minel;
      }
  }

  printf("The smallest range is [%d , %d]\n",minel,maxel);
}

Answer 1

免责声明：这实际上证明了O(n * k^2)的复杂性 - 我还没有（还）删除这个，因为也许有人会在我的推理中找到一个缺陷，或者这可能是真正的复杂性...

你已经注意到内循环是O(k)，问题是外循环执行的次数是多少次？

只要ptr中的某个值为n，外部循环就会停止执行。
ptr[i] = 0的{{1}}开头，对于外部循环的每次执行，您都会在i = 1 .. k中增加单个值。

最糟糕的情况是ptr中的所有值都是连续递增的，即当你得到：

ptr

在这种情况下，循环将在下一次迭代时停止：

ptr = 0 0 0 ... 0
ptr = 1 0 0 ... 0
ptr = 1 1 0 ... 0
...
ptr = 1 1 1 ... 1
ptr = 2 1 1 ... 1

从ptr = n (n-1) (n-1) ... (n-1)到0 0 0 ... 0需要多长时间？ n (n-1) (n-1) ... (n-1)因为一个单元格从O(n * k)到O(n)需要1，而n中有k个单元格。

所以总复杂度似乎是ptr，而不是O(n * k^2) ...

时间复杂度包含来自每个k列表的至少1个元素的最小元素范围

1 个答案: