Question

我做了这个测试，在学习一点Java时挑战自己，我在性能测试中得到了最糟糕的结果，0％。

这是练习：

您将获得两个非空的零索引数组A和B.   N个整数。这些数组代表N个木板。更准确地说，A [K]是   开始时，B [K]是第K个木板的末端。

接下来，给出一个由M组成的非空零索引数组C.   整数。这个数组代表M指甲。更确切地说，C [I]是   你可以在第一钉子上锤击的位置。

如果存在钉子C [I]我们说钉子（A [K]，B [K]）被钉   这样A [K]≤C[I]≤B[K]。

目标是找到必须使用的最少数量的指甲   直到所有的木板被钉上。换句话说，你应该找到一个   值J使得在仅使用第一个木板之后将钉入所有木板   J钉子。更准确地说，对于每个板块（A [K]，B [K]），使得0≤K   ＆LT; N，应该存在指甲C [I]，使得I＆lt; J和A [K]≤C[I]≤   B [K]

例如，给定数组A，B，使得：
A[0] = 1    B[0] = 4
A[1] = 4    B[1] = 5
A[2] = 5    B[2] = 9
A[3] = 8    B[3] = 10 four planks are represented: [1, 4], [4, 5], [5, 9] and [8, 10].
给定数组C：
C[0] = 4
C[1] = 6
C[2] = 7
C[3] = 10
C[4] = 2 if we use the following nails:
0，然后木板[1,4]和[4,5]都将被钉上。 0,1，然后   木板[1,4]，[4,5]和[5,9]将被钉牢。 0,1,2，然后木板   [1,4]，[4,5]和[5,9]将被钉死。 0,1,2,3，然后全部   木板将钉牢。因此，四是指甲的最小数量，   按顺序使用，允许所有木板被钉上。

写一个函数：

class Solution {public int solution（int [] A，int [] B，int [] C）; }

给定两个由N组成的非空零索引数组A和B.   整数和由M组成的非空零索引数组C.   整数，返回按顺序使用的最小指甲数，   允许钉上所有木板。

如果无法钉住所有木板，则该功能应该   返回-1。

例如，给定数组A，B，C，使得：
A[0] = 1    B[0] = 4
A[1] = 4    B[1] = 5
A[2] = 5    B[2] = 9
A[3] = 8    B[3] = 10

C[0] = 4
C[1] = 6
C[2] = 7
C[3] = 10
C[4] = 2 the function should return 4, as explained above.
假设：

N和M是[1..30,000]范围内的整数;每个元素   数组A，B，C是[1..2 * M]范围内的整数; A [K]≤B[K]。   复杂度：

预期的最坏情况时间复杂度为O（（N + M）* log（M））;预期   最坏情况下的空间复杂度是O（M），超出输入存储（不是   计算输入参数所需的存储空间。输入要素   数组可以修改。

这是我的解决方案：

class Solution {
    public int solution(int[] A, int[] B, int[] C) {

        int result = 0;
        int empties = 0;

        for(int i = 0; i < C.length; i ++){

            for(int j = 0; j < A.length; j ++){

                if(A[j] != 0){

                    if(C[i] >= A[j] && C[i] <= B[j]){

                        A[j] = B[j] = 0;
                        empties ++;

                    }
                }

                if(empties == A.length){

                    return i + 1;

                }
            }
        }

        return -1;
    }
}

这是结果的链接：https://codility.com/demo/results/trainingXXEXMW-KVJ/

问题：

首先，我不明白为什么我的表现被测量为O（（N + M）* N）而不是O（M * N），因为我正在做一个（M ）和里面的（N）。免责声明，我几天前才了解Big O表示法。

第二次，很可能是性能不好的原因是因为我没有使用二进制搜索来找到可钉的元素，而是通过它们循环。

然而，我故意这样做，因为在练习的任何部分都没有提到A和B阵列是以1> = A [K]> = A [K + 1]的方式排序的。如果我对这些数组进行排序，那么性能就会很糟糕（我想，不知道这种性能是多么严重地损害了性能，只是猜测）。

您对此有何看法？

Answer 1

我不明白为什么我的表现被测量为O（（N + M）* N）而不是O（M * N）

他们可能正在对有限数量的曲线进行曲线拟合。（这是尝试根据经验确定复杂性的问题。）

如果我对这些数组进行排序，那么表现就会很糟糕（我猜，不知道这种排序会对这种表现造成多大的伤害，只是猜测）。

实际上，如果使用一个好的算法，排序将是O(NlogN)。因此，从复杂性的角度来看，您可以通过排序然后进行二分查找来实现O(NlogN)总体最差情况。（我并不是说这是正确的解决方案......）

Java性能练习：0％

1 个答案: