代码随想录day07| 454.四数相加II、 383. 赎金信 、 15. 三数之和 、 18. 四数之和

题目链接：454.四数相加II

思路：从四个数组中找到四个元素相加等于零，暴力解法就是用四个for循环进行遍历，

如何用到哈希法呢？

——可以效仿两数相加这道题，有四个数组，那么就将他们分成两个数组，先遍历数组1，将其变成哈希表

哈希表的结构是？

——因为数组内的元素范围很大，所以不可以将将元素映射到数组里面，数组的大小难以确定，并且会浪费大量的内存，然后不仅要储存元素，还要储存出现的次数，所以选择使用map，而不使用set，

代码实现

struct hashTable {
    int key;
    int val;
    UT_hash_handle hh;
};

int fourSumCount(int* A, int ASize, int* B, int BSize, int* C, int CSize, int* D, int DSize) {
    struct hashTable* hashtable = NULL;
    for (int i = 0; i < ASize; ++i) {
        for (int j = 0; j < BSize; ++j) {
            int ikey = A[i] + B[j];
            struct hashTable* tmp;
            HASH_FIND_INT(hashtable, &ikey, tmp);
            if (tmp == NULL) {
                struct hashTable* tmp = malloc(sizeof(struct hashTable));
                tmp->key = ikey, tmp->val = 1;
                HASH_ADD_INT(hashtable, key, tmp);
            } else {
                tmp->val++;
            }
        }
    }
    int ans = 0;
    for (int i = 0; i < CSize; ++i) {
        for (int j = 0; j < DSize; ++j) {
            int ikey = -C[i] - D[j];
            struct hashTable* tmp;
            HASH_FIND_INT(hashtable, &ikey, tmp);
            if (tmp != NULL) {
                ans += tmp->val;
            }
        }
    }
    return ans;
}

题目链接：383. 赎金信 

思路：和有效字母异位的解题大体一样，但是，这道题是将两个数组都变成哈希表，然后才进行比较他们的值，如果ransomNote大于magazine，那么就返回false,

为什么不能和有效字母异位一样，只一个哈希表，然后对哈希表进行减值操作呢？

——数组2的值可能会超过数组一的值，那么就会出现一种情况，数值一的值会变成负数，那么就会返回false了

代码实现

bool canConstruct(char* ransomNote, char* magazine) {
    int record1[26] = {0};
    int record2[26] = {0};
    for(int i = 0; i < strlen(ransomNote); i++){
        record[ransomNote[i] - 'a']++;
    }
    for(int i = 0; i < strlen(magazine); i++){
        record[magazine[i] - 'a']++;

    }
    for(int i =0; i <strlen(record); i++){
        if(record1[i] > record2[i])
            return false;
    }
    return true;
}

题目链接：15. 三数之和

思路：可以用三个for遍历三个数组，枚举出每一种可能出现的情况，

为什么不采用哈希表，而是用双指针？

——这道题目和两数之和的区别在于，要进行去重，而对三个数组去重，难度并不小，

为什么用双指针？

——a+b+c可以看成a+(b+c)，把b和c看做一个整体，然后和a进行比较，然后这里就和长度最小的子数组一样，这里滑动窗口是向内收缩

为什么要进行排序？

——因为要进行去重操作，排序可以减少去重的操作

a的去重为什么是nums[i]==nums[i-1]不是nums[i]==nums[i+1]

——前者是向前检查是否有重复，而后者相反，题目要求的是没有重复的三元组，但是里面的元素是可以相同的，所以如果是向后去重的话，那么就有些情况被删去了

//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) {
    //开辟ans数组空间
    int **ans = (int**)malloc(sizeof(int*) * 18000);
    int ansTop = 0;
    //若传入nums数组大小小于3，则需要返回数组大小为0
    if(numsSize < 3) {
        *returnSize = 0;
        return ans;
    }
    //对nums数组进行排序
    qsort(nums, numsSize, sizeof(int), cmp);
    

    int i;
    //用for循环遍历数组，结束条件为i < numsSize - 2(因为要预留左右指针的位置)
    for(i = 0; i < numsSize - 2; i++) {
        //若当前i指向元素>0，则代表left和right以及i的和大于0。直接break
        if(nums[i] > 0)
            break;
        //去重：i > 0 && nums[i] == nums[i-1]
        if(i > 0 && nums[i] == nums[i-1])
            continue;
        //定义左指针和右指针
        int left = i + 1;
        int right = numsSize - 1;
        //当右指针比左指针大时进行循环
        while(right > left) {
            //求出三数之和
            int sum = nums[right] + nums[left] + nums[i];
            //若和小于0，则左指针+1（因为左指针右边的数比当前所指元素大）
            if(sum < 0)
                left++;
            //若和大于0，则将右指针-1
            else if(sum > 0)
                right--;
            //若和等于0
            else {
                //开辟一个大小为3的数组空间，存入nums[i], nums[left]和nums[right]
                int* arr = (int*)malloc(sizeof(int) * 3);
                arr[0] = nums[i];
                arr[1] = nums[left];
                arr[2] = nums[right];
                //将开辟数组存入ans中
                ans[ansTop++] = arr;
                //去重
                while(right > left && nums[right] == nums[right - 1])
                    right--;
                while(left < right && nums[left] == nums[left + 1])
                    left++;
                //更新左右指针
                left++;
                right--;
            }
        }
    }

    //设定返回的数组大小
    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
    int z;
    for(z = 0; z < ansTop; z++) {
        (*returnColumnSizes)[z] = 3;
    }
    return ans;
}

题目链接:18四数之和

int comp(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes) {
    int** quadruplets = malloc(sizeof(int*) * 1001);
    *returnSize = 0;
    *returnColumnSizes = malloc(sizeof(int) * 1001);
    if (numsSize < 4) {
        return quadruplets;
    }
    qsort(nums, numsSize, sizeof(int), comp);
    int length = numsSize;
    for (int i = 0; i < length - 3; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) {
            continue;
        }
        if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
            break;
        }
        if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
            continue;
        }
        for (int j = i + 1; j < length - 2; j++) {
            if (j > i + 1 && nums[j] == nums[j - 1]) {
                continue;
            }
            if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                break;
            }
            if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
                continue;
            }
            int left = j + 1, right = length - 1;
            while (left < right) {
                long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                if (sum == target) {
                    int* tmp = malloc(sizeof(int) * 4);
                    tmp[0] = nums[i], tmp[1] = nums[j], tmp[2] = nums[left], tmp[3] = nums[right];
                    (*returnColumnSizes)[(*returnSize)] = 4;
                    quadruplets[(*returnSize)++] = tmp;
                    while (left < right && nums[left] == nums[left + 1]) {
                        left++;
                    }
                    left++;
                    while (left < right && nums[right] == nums[right - 1]) {
                        right--;
                    }
                    right--;
                } else if (sum < target) {
                    left++;
                } else {
                    right--;
                }
            }
        }
    }
    return quadruplets;
}