c# – GA的适应度函数的时间复杂度

2019年7月2日 202次阅读

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

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

> How to calculate Time Complexity for a given algorithm
> Big-O Complexity Chart
> Determining The Complexity Of Algorithm (The Basic Part)
> How to find time complexity of an algorithm
> Time Complexity of Evolutionary Algorithms for
Combinatorial Optimization: A Decade of Results
.

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

让我告诉你我的健身功能,我猜了几次执行时间.

    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]); – > (1 1)N？
或者这个：actual = cF [i] [j]; – > (1 1)NN？

因此通常,时间复杂度为：1 1(1 N 1 NNNN 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)

最佳答案 通常在进行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,我需要一些恒定的时间d.由于它们被执行N次,因此这里的总时间是cdN.但正如我所提到的,Big-O忽略了这些常数因素,所以我们说它是O(N).
>这些声明是恒定时间,O(1).
>将.NET列表is documented索引为O(1).我找不到DistanceTo方法的文档,但我无法想象它只是O(1),因为它将是简单的数学运算.
>这里我们有另一个执行N次的循环.如果我们对它严格要求,我们会在这里引入第二个变量,因为cF [i] .Count不一定等于cF.Count.我不会那么严格.
>再次,索引到列表是O(1).
>这实际上是棘手的. Add方法is documented如下：

If Count is less than Capacity, this method is an O(1) operation. If the capacity needs to be increased to accommodate the new element, this method becomes an O(n) operation, where n is Count.

>这通常是如何实现的,操作大部分时间都是O(1),但偶尔也是O(n),其中n是要添加的列表的长度,在这种情况下是Fitness.这通常称为amortized O(1).

所以最后你主要只有O(1)操作.但是,在另一个O(N)循环中存在一个O(N)循环.因此整个算法是O(N)* O(N)= O(N2).

点赞