Question

我正在尝试计算我写的遗传算法的适应度函数的时间复杂度。

我做了什么：我已经阅读了一些文章和例子

然而，其中没有一个真的令人满意，我可以说：现在我知道如何在我的代码上应用它。

让我告诉你我的健身功能，我猜到了几次执行时间。

    public static List<double> calculateFitness(List<List<Point3d>> cF, Point3d startpoint)
    {
        List<double> Fitness = new List<double>(); // 1+1
        for (int i = 0; i < cF.Count; i++)  // 1 ; N+1 ; N
        {
            Point3d actual;  // N 
            Point3d next;  // N
            double distance;  // N 
            double totalDistance = startpoint.DistanceTo(cF[i][0]);  // (1+1+1+1)*N
            for (int j = 0; j < cF[i].Count - 1; j++)  // { 1 ; N ; N-1 }*N
            {
                actual = cF[i][j];  // (1+1)*(N-1)
                next = cF[i][j + 1];  // (1+1)*(N-1)

                distance = actual.DistanceTo(next);  // (1+1+1+1)*(N-1)
                totalDistance += distance;  // (1+1)*(N-1)
            }
            totalDistance += cF[i][cF[i].Count - 1].DistanceTo(startpoint);  // (1+1+1+1)*N
            Fitness.Add(totalDistance);  // N
        }
        return Fitness;  // 1
    }

您是否知道有任何示例的链接，以便我可以学习如何计算面向使用的时间复杂度。或者也许有人可以在这里解释一下。例如，对于这段代码我完全不确定：double totalDistance = startpoint.DistanceTo(cF[i][0]); - ＆gt; （1 + 1）N？或者：actual = cF[i][j]; - ＆gt; （1 + 1） N N？

所以一般来说，时间复杂度为：1 + 1 +（1 + N + 1 + N + N + N + N + 4N + N * {1 + N + N-1 + 2 *（N-1））+ 2 *（N-1）+ 4 *（N-1）+ 2 *（N-1）} + 4N + N）= 2 +（2 + 14N + N * {12N-10}）= 12N ^ 2 + 4N + 4 = O（N ^ 2）

Answer 1

通常在进行Big-O分析时，我们忽略恒定时间操作（即O（1））和任何常数因子。我们只是试图了解算法与 N 的缩放程度。这在实践中意味着我们正在寻找循环和非恒定时间操作

考虑到这一点，我在下面复制了您的代码，然后注释了某些感兴趣的点。

public static List<double> calculateFitness(List<List<Point3d>> cF, Point3d startpoint)
{
    List<double> Fitness = new List<double>();
    for (int i = 0; i < cF.Count; i++)  // 1.
    {
        Point3d actual;  // 2. 
        Point3d next; 
        double distance;  
        double totalDistance = startpoint.DistanceTo(cF[i][0]);  // 3.
        for (int j = 0; j < cF[i].Count - 1; j++)  // 4.
        {
            actual = cF[i][j];  // 5.
            next = cF[i][j + 1];

            distance = actual.DistanceTo(next);
            totalDistance += distance;
        }
        totalDistance += cF[i][cF[i].Count - 1].DistanceTo(startpoint);
        Fitness.Add(totalDistance); // 6.
    }
    return Fitness;
}

i循环将执行 N 次，其中 N 为cF.Count。如果我们非常正式，我们会说比较i < cF.Count需要一些恒定时间 c 而i++需要一些恒定时间 d 。由于它们执行 N 次，因此此处的总时间为 cdN 。但正如我所提到的，Big-O忽略了这些常数因素，所以我们说它是O（ N ）。
这些声明是固定时间，O（1）。
索引到.NET List is documented为O（1）。我找不到DistanceTo方法的文档，但我无法想象它只是O（1），因为它是简单的数学运算。
这里我们有另一个执行 N 次的循环。如果我们对此严格要求，我们会在这里引入第二个变量，因为cF[i].Count不一定等于cF.Count。我不会那么严格。
同样，索引到列表中的是O（1）。
这实际上是棘手的。 Add方法is documented如下：

如果Count小于Capacity，则此方法为O（1）操作。如果需要增加容量以容纳新元素，则此方法将成为O（n）操作，其中n为Count。
- 通常如何实现，操作大部分时间为O（1），但偶尔为O（ n ），其中 n 是列表的长度在这种情况下被添加到Fitness。这通常称为 amortized O（1）。

所以最后你主要只有O（1）操作。但是在另一个O（ N ）循环中有一个O（ N ）循环。因此整个算法是O（ N ）* O（ N ）= O（ N ² ）

GA的适应度函数的时间复杂度

1 个答案: