LeetCode 18. 四数之和 4Sum（C语言）

题目描述：

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

题目解答：

方法1：双指针

采用和三数之和相同的方法，先排序，然后外边是两层for循环，里边用双指针。注意需要跳过重复元素。
在该题中有一些优化措施，比如在两层循环之内，前两个数字a, b已经确定，现在我们选择最后两个数字c, d（加上前两个数字a, b）来组成目标四个数字，此时如果比target还小，说明即使后两个数字我们选择最大的，也不能等于target，所以前两个数字a, b选的太小了，所以可以直接增大第二个数字b；如果现在我们选择第二个数字b后边紧接着的两个数字c, d（加上前两个数字a, b）来组成目标四个数字，此时如果比target大，则无论如何也不会等于target，即前两个数字选的太大了，所以可以直接跳出，增大第一个数，第二个数字重新开始。
另外我先过滤了一些不合题意的数字，包括排序后数组最前边的和最后边的。比如最前边的，先假设我们选用最后三个最大的数字，此时加上最前边的数字a，其和比target还小，说明a这个数字太小，无效，需要向后挪动。
运行时间4ms，代码如下。

/**
 * Return an array of arrays of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int comp(const void* a, const void* b) {
    return (*(int*)a > *(int*)b ? 1 : -1);
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
    int n = numsSize, i = 0, j = 0;
    if(n < 4)
        return NULL;
    qsort(nums, n, sizeof(int), comp);
    int start = 0, end = 0;
    int temp = nums[n - 1] + nums[n - 2] + nums[n - 3];
    for(start = 0; start < n - 3 && nums[start] + temp < target; start++) {    }
    if(start == n - 3)
        return NULL;
    temp = nums[0] + nums[1] + nums[2];
    for(end = n - 1; end > 2 && nums[end] + temp > target; end--) {    }
    if(end == 2)
        return NULL;
    // start <= i <= end
    n = end - start + 1;
    nums += start;
    int** result = NULL;
    int left = 0, right = 0, size = 0;
    for(i = 0; i < n - 3; i++) {
        for(j = i + 1; j < n - 2; j++) {
            if(nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target)
                break;
            if(nums[i] + nums[j] + nums[n - 1] + nums[n - 2] < target)
                continue;
            left = j + 1; right = n - 1;
            while(left < right) {
                temp = nums[i] + nums[j] + nums[left] + nums[right];
                if(temp < target)
                    left++;
                else if(temp > target)
                    right--;
                else {
                    size++;
                    result = (int**)realloc(result, size * sizeof(int*));
                    result[size - 1] = (int*)malloc(4 * sizeof(int));
                    result[size - 1][0] = nums[i]; result[size - 1][1] = nums[j];
                    result[size - 1][2] = nums[left]; result[size - 1][3] = nums[right];
                    while(nums[left] == nums[left + 1])
                        left++;
                    while(nums[right] == nums[right - 1])
                        right--;
                    left++;
                    right--;
                }
            }
            while(nums[j] == nums[j + 1])
                j++;
        }
        while(nums[i] == nums[i + 1])
            i++;
    }
    *returnSize = size;
    return result;
}

方法2：两组双指针

外边是一组双指针，里边也是一组双指针。注意重复元素的过滤。外层双指针的重复元素过滤不能放在最下边。因为对于右侧的重复元素，有可能在增加了left1之后还能使用，如果直接过滤掉，会导致缺少结果。
运行时间4ms，代码如下。

/**
 * Return an array of arrays of size *returnSize.
 * Note: The returned array must be malloced, assume caller calls free().
 */
int comp(const void* a, const void* b) {
    return (*(int*)a > *(int*)b ? 1 : -1);
}
int** fourSum(int* nums, int numsSize, int target, int* returnSize) {
    int n = numsSize, i = 0, j = 0;
    if(n < 4)
        return NULL;
    qsort(nums, n, sizeof(int), comp);
    int start = 0, end = 0;
    int temp = nums[n - 1] + nums[n - 2] + nums[n - 3];
    for(start = 0; start < n - 3 && nums[start] + temp < target; start++) {    }
    if(start == n - 3)
        return NULL;
    temp = nums[0] + nums[1] + nums[2];
    for(end = n - 1; end > 2 && nums[end] + temp > target; end--) {    }
    if(end == 2)
        return NULL;
    // start <= i <= end
    n = end - start + 1;
    nums += start;
    int** result = NULL;
    int left1 = 0, right1 = n - 1, t = 0;
    int left2 = 0, right2 = 0, size = 0;
    while(left1 < right1) {   
        if(left1 > 0 && nums[left1] == nums[left1 - 1]) {
            left1++;
            continue;
        }
        if(right1 < n - 1 && nums[right1] == nums[right1 + 1]) {
            right1--;
            continue;
        } 
        t = target - nums[left1] - nums[right1];
        if(t > 2 * nums[right1]) {
            left1++;
            continue;
        }  
        if(t < 2 * nums[left1]) {
            left1 = 0;
            right1--;
            continue;
        }
        left2 = left1 + 1; right2 = right1 - 1;
        while(left2 < right2) {
            temp = nums[left2] + nums[right2] - t;
            if(temp < 0)
                left2++;
            else if(temp > 0)
                right2--;
            else {
                size++;
                result = (int**)realloc(result, size * sizeof(int*));
                result[size - 1] = (int*)malloc(4 * sizeof(int));
                result[size - 1][0] = nums[left1]; result[size - 1][1] = nums[right1];
                result[size - 1][2] = nums[left2]; result[size - 1][3] = nums[right2];
                while(nums[left2] == nums[left2 + 1])
                    left2++;
                while(nums[right2] == nums[right2 - 1])
                    right2--;
                left2++;
                right2--;
            }
        }
        left1++;
    }
    *returnSize = size;
    return result;
}