四. leetcode_比赛_1

第200次周赛，没有赶上正式比赛，是自己私下的练习，也是一个新的开始吧。但是感觉时间用的非常多，4道题几乎花了3个小时，而且不是全部做出来。虽然结果不是太好，但是也是一个新的尝试。链接：https://leetcode-cn.com/contest/weekly-contest-200/

1. 统计好三元组

这是一道简单题。我其中忙中出错，曾经试过将检索j写成了i，但总体问题不大。很快就做好了，不谈。

int abs(int x)
{
    if(x < 0) return -1 * x;
    return x;
}

int countGoodTriplets(int* arr, int arrSize, int a, int b, int c){
    int res = 0;
    for(int i = 0; i < arrSize; i++)
    {
        for(int j = i + 1; j < arrSize; j++)
        {
            for(int k = j + 1; k < arrSize; k++)
            {
                if(abs(arr[i] - arr[j]) <= a && abs(arr[j] - arr[k]) <= b && abs(arr[i] - arr[k]) <= c)
                    res++;
            }
        }
    }
    return res;
}

2. 找出数组游戏的赢家

    一道中等题，感觉难度中等偏下。印象中在逻辑推理上花的时间较多，而在编程上花的比逻辑推理仅多一些。应该是20分钟内写完的。

int getWinner(int* arr, int arrSize, int k){
    int nowNum = 0, cmpNum = 0, win = 0;
    int flag = 0;
    for(nowNum = 0; nowNum < arrSize; nowNum++)
    {
        if(flag == 0)
        {
            win = 0; flag = 1;
        }else
            win = 1;
        for(cmpNum = nowNum + 1; cmpNum < arrSize; cmpNum++)
        {
            if(arr[nowNum] > arr[cmpNum])
                win++;
            else
                break;
        }
        if(win >= k)
            return arr[nowNum];
    }
    
    int max = 0;
    for(int i = 0; i < arrSize; i++)
    {
        if(arr[i] > max)
            max = arr[i];
    }
    return max;
}

3. 排布二进制网络的最少交换次数

    中等题。这是一道经典的思路思路简单的“硬编程题”。印象中想出思路花了一些时间，但是编程上花的时间相当多，感觉一小时左右。需要处理许多的边界情况，但是总体思路并不难。

void swap(int** a, int** b)
{
    int *temp = NULL;
    temp = *a;
    *a = *b;
    *b = temp;
}

int findOpAndUpdate(int** grid, int gridSize, int aim, int* swapToAim)
{
    int indexOfAim = 0, i = 0;
    for(indexOfAim = aim; indexOfAim < gridSize; indexOfAim++)
    {
        for(i = gridSize - 1; i > aim; i--)
            if(grid[indexOfAim][i] == 1) break;
        if(i == aim)
            break;
    }
    if(indexOfAim == gridSize) return -1;
    
    int opNum = swapToAim[indexOfAim];
    for(int i = indexOfAim; i > aim; i--)
        swap(&grid[i], &grid[i - 1]);
    for(int i = aim + 1; i < gridSize; i++)
        swapToAim[i]--;
    return opNum;
}

int minSwaps(int** grid, int gridSize, int* gridColSize){
    int aim = 0, swapToAim[gridSize];
    for(int i = 0; i < gridSize; i++) swapToAim[i] = i;
    
    int opSum = 0, opNum = 0;
    for(aim = 0; aim < gridSize; aim++)
    {
        opNum = findOpAndUpdate(grid, gridSize, aim, swapToAim);
        if(opNum == -1) return -1;
        opSum += opNum;
    }
    return opSum;
}

4. 最大得分

    一道困难题，但是感觉难度在困难中偏下。和第三题类似，是思路较简单的“硬编程题”，这类型的题目通常需要处理许多边界问题，要很细心。但是奇怪的是，我的代码在本地可以成功执行例子，并且输出正确结果，而在leetcode却提示我数组越界（heap-buffer-overflow）。不知道是什么原因。编程用了一个半小时，但也不能说完全正确。

int min(long long a, long long b)
{
    if(a < b) return a;
    return b;
}

int max(long long a, long long b)
{
    if(a > b) return a;
    return b;
}

void swapAll(int** numsMain, int* numsSizeMain, int* walkMain, int** numsPara, int* numsSizePara, int* walkPara)
{
    int* temp = *numsMain;
    *numsMain = *numsPara;
    *numsPara = temp;

    int t = *numsSizeMain;
    *numsSizeMain = *numsSizePara;
    *numsSizePara = t;

    t = *walkMain;
    *walkMain = *walkPara;
    *walkPara = t;
}

int maxSum(int* nums1, int nums1Size, int* nums2, int nums2Size){
    int* numsMain = nums1, *numsPara = nums2;
    int numsSizeMain = nums1Size, numsSizePara = nums2Size;
    int walkMain = 0, walkPara = 0;

    printf("-----1------\n");

    long long res1 = 0;
    while(walkMain != numsSizeMain)
    {
        for(; walkPara < numsSizePara; walkPara++)
            if(numsPara[walkPara] >= numsMain[walkMain])
                break;

        if(numsPara[walkPara] > numsMain[walkMain] || (walkPara == numsSizePara && numsMain[walkMain] > numsPara[walkPara - 1]))
        {
            res1 += numsMain[walkMain++];
        }else if(numsPara[walkPara] == numsMain[walkMain])
        {
            res1 += numsMain[walkMain];
            walkPara++;
            swapAll(&numsMain, &numsSizeMain, &walkMain, &numsPara, &numsSizePara, &walkPara);
        }
    }

    numsMain = nums2, numsPara = nums1;
    numsSizeMain = nums2Size, numsSizePara = nums1Size;
    walkMain = walkPara = 0;

    long long res2 = 0;
    while(walkMain != numsSizeMain)
    {
        for(; walkPara < numsSizePara; walkPara++)
            if(numsPara[walkPara] >= numsMain[walkMain])
                break;
 
        if(numsPara[walkPara] > numsMain[walkMain] || (walkPara == numsSizePara && numsMain[walkMain] > numsPara[walkPara - 1]))
        {
            res2 += numsMain[walkMain++];

        }else if(numsPara[walkPara] == numsMain[walkMain])
        {
            res2 += numsMain[walkMain];
            walkPara++;
            swapAll(&numsMain, &numsSizeMain, &walkMain, &numsPara, &numsSizePara, &walkPara);
        }
    }

    return max(res1, res2);
}

总结

     这次个人练习，每一题基本上都具有思路，前面三题也做出来了，但是时间需要缩短。虽然相对排名靠前的大佬很差，但我个人对第一次参加有这样的结果也是满意，及格以上，可以给65分。