减少使用二进制搜索的代码的执行时间

Question

问题是根据其他 2 个 arrays 创建玩家排名数组：排行榜和玩家分数。 此处问题的更多解释： https://www.hackerrank.com/challenges/climbing-the-leaderboard/problem 。

下面的代码是一个意大利面条，但它工作正常。 但是，对于大尺寸的排序数组（例如 200000 个元素），它会超时。 我不要求复制/粘贴代码。 我只想知道是否有优化此代码的方法。

int* climbingLeaderboard(int ranked_count, int* ranked, int player_count, int* player, int* result_count) {
    
    *result_count=player_count;
    // remove duplicates
    int removed=0;
    for(int i=0, j=1; i<ranked_count-removed; i++, j++){   
      if(ranked[i]==ranked[j]){
        for(int k=j; k<ranked_count-removed; k++) 
           ranked[k]=ranked[k+1]; 
        removed++;
      }
    }
    int newsize=ranked_count-removed;
    // create an array to store ranks then fill it
    int* positions=malloc(newsize*sizeof(int));
    positions[0]=1;
    for(int i=0, j=1; j<newsize; i++, j++){
        positions[j]=(ranked[j]<ranked[i])? (positions[i]+1) : positions[i];
    }
    // create and fill the results array using binary search
    int* res = malloc(player_count*sizeof(int));
    int start=0, end=newsize-1, middle=(start+end)/2;
    int j, k=newsize-1;
    for(int i=0; i<player_count; i++){
        if(i>0&&player[i]==player[i-1]){
            *(res+i)=(*(res+(i-1))); 
            continue;
        }
        if(player[i]>=ranked[middle]){
            *(res+i)=positions[middle]; 
            j=middle-1;
            while(j>=0){
                if(player[i]>=ranked[j]) 
                    *(res+i)=positions[j];
                else if(j==k) 
                    *(res+i)=positions[j]+1; 
                else break; 
                --j;
            }
            start=0; end=middle-1;
        }
        else{
            *(res+i)=positions[newsize-1]+1; 
            j=newsize-1;
            while(j>=middle){
                if(player[i]>=ranked[j]) 
                    *(res+i)=positions[j];
                else if(j==k) 
                    *(res+i)=positions[j]+1; 
                else break; 
                --j;
            }
            start=middle+1; end=newsize-1;
        }
        middle=(start+end)/2;
    }
    free(positions);
    return res;
}

Answer 1

删除重复项的初始循环具有潜在的二次时间复杂度。 您可以使用 2 指方法实现线性复杂度：

    int removed = 0;
    for (int i = 1, j = 1; j < ranked_count; j++) {
        if (ranked[i - 1] != ranked[j])
            ranked[i++] = ranked[j];
        else
            removed++;
    }

更一般地说，参数 arrays 不应该改变，尽管给出了草率的原型：

int *climbingLeaderboard(int ranked_count, int *ranked,
                         int player_count, int *player,
                         int *result_count);

以下是我建议解决此问题的简单步骤：

• 分配并初始化一个ranking数组，其中包含排名数组中每个分数的ranked 。 小心分配ranked_count + 1元素。
• 分配一个长度为player_count的结果数组res ，将result_count设置为player_count 。
• 从pos = ranked_count开始，对于player中的每个条目i ：
  • 使用二进制搜索在 position 0和当前pos （含）之间找到条目将插入ranking数组的位置pos位置。 确保找到最小的条目以防出现重复分数。
  • 将res[i]设置为ranking[pos]
• 释放ranking数组
• 返回res数组。

这是一个简单的实现：

int *climbingLeaderboard(int ranked_count, int *ranked,
int player_count, int *player,
int *result_count)
{
if (player_count <= 0) {
*result_count = 0;
return NULL;
}
int *ranking = malloc(sizeof(*ranking) * (ranked_count + 1));
int rank = 1;
ranking[0] = rank;
for (int i = 1; i < ranked_count; i++) {
if (ranked[i] != ranked[i - 1])
rank++;
ranking[i] = rank;
}
ranking[ranked_count] = rank + 1;

int *res = malloc(sizeof(*res) * player_count);
*result_count = player_count;

int pos = ranked_count;
for (int i = 0; i < player_count; i++) {
int start = 0;
while (start < pos) {
int middle = start + (pos - start) / 2;
if (ranked[middle] > player[i])
start = middle + 1;
else
pos = middle;
}
res[i] = ranking[pos];
}
free(ranking);
return res;
}

Answer 2

寻找使用“无分支”来提高执行速度的方法：

    positions[0]=1;
    for(int i=0, j=1; j<newsize; i++, j++){
        positions[j]=(ranked[j]<ranked[i])? (positions[i]+1) : positions[i];
    }

成为

    positions[0] = 1;
    for( int i = 0, j = 1; j < newsize; i++, j++ )
        positions[j] = positions[i] + (ranked[j] < ranked[i]);

除此之外，我什至不想弄清楚这段代码试图做什么。