Algorithm 3数组情况下的代码复杂性

给出了三个排序数组（按升序排列），您需要找到一个三元组（每个数组中有一个元素），这样距离就最小。 距离的定义如下： 如果

a[i]、b[j]

和

c[k]

是三个元素，那么

distance = max{abs(a[i]-b[j]),abs(a[i]-c[k]),abs(b[j]-c[k])}

请给出O（n）时间复杂度的解决方案

线性时间算法：

double MinimalDistance(double[] A, double[] B, double[] C)
{
    int i,j,k = 0;
    double min_value = infinity;
    double current_val;
    int opt_indexes[3] = {0, 0, 0);

    while(i < A.size || j < B.size || k < C.size)
    {
         current_val = calculate_distance(A[i],B[j],C[k]);
         if(current_val < min_value)
         {
               min_value = current_val;
               opt_indexes[1] = i;
               opt_indexes[2] = j;
               opt_indexes[3] = k;
         }    

         if(A[i] < B[j] && A[i] < C[k] && i < A.size)
             i++;
         else if (B[j] < C[k] && j < B.size)
             j++;
         else
             k++; 
    }

    return min_value;
}

double最小距离（double[]A、double[]B、double[]C）
{
int i，j，k=0；
双最小值=无穷大；
双电流；
int opt_索引[3]={0,0,0）；
而（i

在每个步骤中，检查当前距离，然后增加当前指向最小值的数组的索引。每个数组只迭代一次，这意味着运行时间为

O（A.size+B.size+C.size）

---

如果您想要最佳索引而不是最小值，您可以返回

opt_index

而不是

min_value

假设我们只有一个排序数组，那么3个可能距离较小的连续元素是理想的解决方案。现在，当我们有三个数组时，只需将它们全部合并并生成一个大的排序数组rray ABC（这可以通过合并排序中的合并操作在O（n）中完成），只需保留一个标志来确定哪个元素属于哪个原始数组。现在您必须在数组中找到三个连续的元素，如下所示：

a1,a2,b1,b2,b3,c1,b4,c2,c3,c4,b5,b6,a3,a4,a5,....

这里的“连续”是指它们按连续顺序属于3个不同的组，例如：a2、b3、c1或c4、b6、a3

现在找到这个树元素并不难，确定最小和最大的元素应该是某个三元组中第一个和最后一个组的元素中的最后一个和第一个，例如在组：[c2，c3，c4]，[b5，b6]，[a3，a4，a5]中，我们不需要检查

a4，a5，c2，c3

很明显，在这种情况下可能的解决方案是在c4，[b5，b6]中，a5，我们也不需要将c4与b5、b6或a5与b5、b6进行比较，确保距离由a5-c4（在该组中）确定。因此，我们可以从左侧开始，跟踪最后一个元素，并在每次迭代中更新最佳可能解，只需保持每组的最后访问值

示例（首先我应该说我没有编写代码，因为我认为这是OP的任务，而不是我）：

假设在排序数组之后有以下序列：

a1,a2,b1,b2,b3,c1,b4,c2,c3,c4,b5,b6,a3,a4,a5,....

让我们一步一步地迭代：

我们只需要跟踪数组中每个项目的最后一项，

a

用于跟踪当前最佳a_i，b代表b_i，c代表c_i。假设首先a_i=b_i=c_i=-1

在第一步中，a将是a1，在下一步中

a=a2,b=-1,c=-1
a=a2,b=b1,c=-1
a=a2,b=b2,c=-1
a=a2,b=b3,c=-1,
a=a2,b=b3,c=c1,

此时，我们将当前指针（a2、b3、c1）保存为差异的最佳值

下一步：

a=a2,c=c1,b=b4

现在，我们比较b4-a2与以前最佳选项的差异，如果更好，我们将此指针保存为解决方案，直到现在，我们继续：

a=a2,b=b4,c=c2 (again compare and if needed update the best solution),
a=a2,b=b4,c=c3 (again ....)
a=a2,b=b4,c=c4 (again ....)
a=a2, b=b5,c=c4, ....

好的，如果文本中不清楚，合并后我们有（我假设所有数组都至少有一个元素）：

解=无限； a=b=c=-1， bestA=bestB=bestC=1

for (int i=0;i<ABC.Length;i++)
{
    if(ABC[i].type == "a") // type is a flag determines 
                           // who is the owner of this element
    {
        a=ABC[i].Value; 
        if (b!=-1&&c!=-1)
        {
          if (max(|a-b|,|b-c|,|a-c|) < solution)
          {
            solution =  max(|a-b|,|b-c|,|a-c|);
            bestA= a,bestB = b,bestC = c;
          }
        }
    }
    // and two more if for type "b" and "c"
}

---

for（int i=0；我能告诉你你能想出的最好的解决方案吗？或者至少有一两次没有成功的尝试？解决方案在中进行了解释，但无法理解。你解释的单数组的基本步骤很容易理解。例如，如果数组是2,3,6,8,9——三元组将是（6,8,9）因为9-6=3是最小的。当您有不同的数组时，我合并并创建一个排序数组（假设我存储了关于这些元素来自哪个数组的信息）。如何从这一步开始？？你能用一个例子来解释吗？@PavanRavishankar，我试图用示例和伪代码来详细说明。@maggot092这是解释算法的伪代码。说你通过调用大小函数来计算复杂度是错误的。
while
循环应该是
while（i