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

Posted 2023-02-22

【中文标题】包含 k 个列表中每个列表中至少一个元素的最小元素范围的时间复杂度

【英文标题】：Time Complexity of smallest range of elements containing at least 1 element from each of the k lists

【发布时间】：2017-07-06 17:38:18

【问题描述】：

谁能详细说明这个函数的时间复杂度是多少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);
  

【问题讨论】：

n^2 IS 两个嵌套循环。而k 只是列表的数量（测试数据）

你确定这是O(n^2 * k)吗？不是O(n * k^2)吗？

【参考方案1】：

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

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

一旦ptr 中的值之一是n，外部循环将停止执行。 您从ptr[i] = 0 开始，对于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，而ptr 中有k 单元格。

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