创建最低成本数组

Question

我有一个大小为n + 1的数组，我希望存储购买n项目的最低成本（第i^th索引存储i^th项目的成本）。

有m不同的卖家：每个卖家将项目L提供给项目R （其中L ， R > = 1且L ， R <= n），每个成本为C

要创建成本最低的数组，我执行了以下操作：

for (int i=1; i<=m; i++) {
    int L = L of i^th seller
    int R = R of i^th seller
    int C = selling price of i^th seller
    for (int j=L; j<=R; j++) {
        if (leastCost[j]==0 || leastCost[j]>C) {
            leastCost[j]=C
    }
}

构造该数组是O(n*m) ，访问该数组是O(1) 。

对于非常大的n和m值，是否有更好的方法来构建成本最低的数组？

也许是一种不将其存储在数组中的不同方法，以及其他方面可以减少整体时间复杂度？

Answer 1

你可以在这里使用某种形式的堆栈

如果L相等，则按L和C desc排序所有卖家。

然后从第一卖家开始（与李敏）

如果堆栈为空，则将其置于堆栈中。 如果没有更多的卖家

(Lj == Li)

然后cost[Li] = C[i]和Li++ （堆叠）

如果有Lj == Li条目那么

• 如果Rj < Ri和Cj > Ci跳过

• 如果Rj < Ri且Cj < Ci将此卖家添加到堆叠中

• 如果Rj > Ri和Cj > Ci然后流行当前卖家（i），添加此卖家（j）并添加卖家（i）

Answer 2

当然，我们可以做得比O（n * m）更好，而且解决方案也非常简单。

以下是解决此问题的伪代码：

Construct a MIN-HEAP of the sellers based on their costs c.

Construct another array x[1...n] with its each element set to 0 initially.

Do the following initializations:
 count=0

while(count < n)
{
 S = EXTRACT_MIN(Heap)
 if(count==0)
 {            
  for(j=S.L to S.R)
  {
   leastCost[j]=S.c
   ++count
   x[j]=S.R
  } 
 }
 else
 {
  for(j=S.L;j<=S.R;++j)
  {
   if(x[j]!=0)
   {
    i=x[j] and continue;
   }
   else 
   {
    leastCost[j]=S.c
    ++count
    x[j]=S.R
   }
  }
 }
}

说明

我们在这个问题上可以实现的最佳优化是我们跳过所有已经填充的数组索引，因为它们已经具有最低成本。

x辅助数组 ：数组x帮助我们跳过所有已填充的数组索引，因为：

x [i]存储索引j，使得i到j已经在数组中填充了最少的成本，因此这是使用条件语句的原因：

if(x[i]!=0)
{
 i=x[i] and continue;
}

所以基本上它帮助我们直接跳到未填充的索引。

MIN-HEAP ：它允许我们找到时间O（logm）中存在的所有成本的最小成本c。

时间复杂性

因为我们最多n次访问数组leastCost因此访问数组： O（n）

构建堆需要O（m）

在最坏情况下，所有卖家都会对某些指数做出贡献，并且会有精确的m EXTRACT_MIN（堆）操作，每次都需要O（logm）时间，因此时间为： O（m * logm） 。

因此总时间复杂度= O（n + mlogm + m）= O（n + mlogm） 。

顺便说一句，如果我使用C语言，我会使用struct for Seller，如果是Java，那么Seller.Feel的类可以免费提供任何查询。

Answer 3

此问题是一个典型的问题范围最小查询 ，您可以使用Segment树来获取具有时间复杂度O（m log n）的解决方案，以便为每个查询创建树和O（log n）。

更多细节：

我们使用树来表示从1到n的每个项目的最低价格。

对于每个卖家，我们更新树：

tree.update(L, R, C);

最后，为了获得项目i的最小值，我们查询树：

tree.getMin(i, i);

由于update和getMin都具有时间复杂度O（log n），因此整个程序的时间复杂度为O（max（m，n）log n）。 您无需修改​​原始Segment树实现中的任何内容。