算法刷题 DAY7

383赎金信

bool canConstruct(char* ransomNote, char* magazine) {
    int hash[26] = {0};
    int i = 0;

    while (magazine[i] != '\0') {
        hash[magazine[i] - 'a']++;//不用去重
        i++;
    }

    i = 0;
    while (ransomNote[i] != '\0') {
        hash[ransomNote[i] - 'a']--;
        if (hash[ransomNote[i] - 'a'] < 0)//不用去重
            return false;
        i++;
    }

    return true;
}

15.三数之和

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume
 * caller calls free().
 */
// qsort辅助cmp函数
int cmp(const void* ptr1, const void* ptr2) {
    return *((int*)ptr1) > *((int*)ptr2);
}
int** threeSum(int* nums, int numsSize, int* returnSize,
               int** returnColumnSizes) {

    int** ans =
        (int**)malloc(sizeof(int*) * 18000); //要写18000，不然申请的空间可能不够
    int ans_index = 0;

    if (numsSize < 3) {
        // printf(" %d\n",returnSize[0]);
        *returnSize = 0;
        return ans;
    }
    // printf(" %d\n",returnSize[0]);
    //第一步：对数组进行排序
    qsort(nums, numsSize, sizeof(int), cmp); //快排

    for (int i = 0; i < numsSize - 2; i++) { //要-2 防止left，right无意义
        if (nums[i] > 0)//剪枝
            break; //若num[i]>0,即三元组最小元素>0，所组三元组一定不满足要求
        if (i > 0 && nums[i] == nums[i - 1])//去重
            continue;
        //三元组不能重复，三元组里面的元素可以重复
        // 错误去重a方法，将会漏掉-1,-1,2 这种情况
        /*
        if (nums[i] == nums[i + 1]) { //比较的是i和left 即三元组内元素是否重复
            continue;
        }
        */
        // 正确去重a方法 ：三元组是否重复
        /*if (i > 0 && nums[i] == nums[i - 1]) {//
           i>0用于防止下标出现小于0的情况 continue;
                   }*/
        int left = i + 1, right = numsSize - 1;
        while (left < right) { // left=right时，只有两个数了，故排除
            int sum = nums[i] + nums[left] + nums[right]; //要放在while内部
            if (left < right && sum > 0)
                right--;
            else if (left < right && sum < 0)
                left++;
            else {
                int* arr = (int*)malloc(sizeof(int) * 3);
                arr[0] = nums[i];
                arr[1] = nums[left];
                arr[2] = nums[right];
                //*returnSize++;  错误 据C语言的运算符优先级， 优先级高于 ，所以
                //的含义是先将指针i指向的整数值取出，然后指针i自增1
                // printf(" %d\n",returnSize[0]);
                ans[ans_index++] = arr;
                //对left，right的去重一定要放在收获结果之后，不然去重之后可能丢失结果
                //如{0，0，0，0，0}
                while (left < right && nums[left] == nums[left + 1])
                    left++;
                while (left < right && nums[right] == nums[right - 1])
                    right--;
                left++;
                right--; // while循环结束，left和right所处位置的元素仍然和上个三元组相同故还要移位一次
            }
        }
    }
    *returnSize = ans_index;
    *returnColumnSizes = (int*)malloc(sizeof(int) * ans_index);更新每行的列数

    for (int j = 0; j < ans_index; j++) {
        (*returnColumnSizes)[j] = 3;//更新每行的列数
    }
    return ans;
}

四数之和

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume
 * caller calls free().
 */

int cmp(const void* ptr1, const void* ptr2) {
    return *((int*)ptr1) > *((int*)ptr2);
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize,
              int** returnColumnSizes) {
    int** ans = (int**)malloc(sizeof(int*) * 18000);
    *returnSize = 0;
    if (numsSize < 4)
        return ans;
    qsort(nums, numsSize, sizeof(int), cmp);
   // for (int i = 0; i < numsSize; i++) {
        // printf(" %d ",nums[i]);
    //}
    // printf("\n");

    for (int k = 0; k < numsSize - 3; k++) {//-3
        if (nums[k] > target && nums[k] >= 0)
            break;
//区别三数之和=0 用num[i]>0剪枝
//四数之和不可以用num[k]>target 来剪枝 因为target可能小于0 →几个数相加可能越减越小
//k和i都要剪枝，去重
        // printf(" 1 ");
        if (k > 0 && nums[k] == nums[k - 1])
            continue;

        for (int i = k + 1; i < numsSize - 2; i++) {//-2
            if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {//k和i视为一个整体
                break;
                // printf(" 2 ");
            }
            if (i > k + 1 && nums[i] == nums[i - 1])
                continue;

            int left = i + 1;
            int right = numsSize - 1;
            while (left < right) {
                int sum = nums[k] + nums[i] + nums[left] + nums[right];

                // printf(" 4 sum=%d ",sum);
                if ((long long)nums[k] + nums[i] + nums[left] + nums[right] >
                    target)
                    right--; //是target，不是0，区别三数之和;
                //要加longlong不然可能超出表示范围
                else if ((long long)nums[k] + nums[i] + nums[left] +
                             nums[right] <
                         target)
                    left++;
                else {
                    ans[*returnSize] = (int*)malloc(sizeof(int) * 4);
                    ans[*returnSize][0] = nums[k];
                    ans[*returnSize][1] = nums[i];
                    ans[*returnSize][2] = nums[left];
                    ans[*returnSize][3] = nums[right];
                    // printf("\n 3 %d %d %d %d\n
                    // ",nums[k],nums[i],nums[left],nums[right]);
                    (*returnSize)++;
                    while (left < right && nums[left] == nums[left + 1])
                        left++;
                    while (left < right && nums[right] == nums[right - 1])
                        right--;
                    right--;
                    left++;
                }
            }
        }
    }
    *returnColumnSizes = (int*)malloc(sizeof(int) * (*returnSize));//是returnSize，别写成ans_index
    // printf(" 5 ");
    for (int j = 0; j < *returnSize; j++) {//是returnSize，别写成ans_index
        (*returnColumnSizes)[j] = 4;
    }
    // printf("returnSize= %d ",(*returnSize));
    return ans;
}