LeetCode 15 三数之和, LeetCode 4 两个排序数组的中位数

三数之和

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

思路

首先三数之和可以转变成两数之和，如a+b+c=0变为-a=b+c。遇到这种寻找数组中某个特征相关的题目，通常来说排个序没什么坏处。然后利用双指针，一个从前一个从后扫描，找到两个数使得值为a的相反数。注意，为了避免重复，每次用完一个值之后跳过紧跟在后面的相同值。

当a大于0时，其相反数小于0，也就是b+c要小于0；由于按照升序处理后，a后面的数肯定比a大，也就都大于0，因此b+c是不可能再小于0的，后面的情况就可以不考虑了。

代码

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        int n = nums.size();
        sort(nums.begin(), nums.end());
        for(int i = 0; i < n-2; i++){
            int target = -nums[i];
            if(nums[i]>0) break;
            int front = i+1, back = n-1;
            while(front < back){
                int sum = nums[front]+nums[back];
                if(sum < target){
                    front++;
                } else if(sum > target){
                    back--;
                } else {
                    vector<int> temp;
                    temp.push_back(nums[i]);
                    temp.push_back(nums[front]);
                    temp.push_back(nums[back]);
                    res.push_back(temp);
                    while(front < back && nums[front] == temp[1]) front++;
                    while(front < back && nums[back] == temp[2]) back--;
                }
            }
            while(i<n-2 && nums[i]==nums[i+1]) i++;
        }
        return res;
    }
};

结果

明显看出时间复杂度为O(n^2)。

两个排序数组的中位数

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2 。
请找出这两个有序数组的中位数。要求算法的时间复杂度为 O(log (m+n)) 。
你可以假设 nums1 和 nums2 不同时为空。

示例1：

nums1 = [1, 3]
nums2 = [2]

中位数是 2.0

示例2：

nums1 = [1, 2]
nums2 = [3, 4]

中位数是 (2 + 3)/2 = 2.5

解法1

一开始没考虑那么多，直接找中位数，即从两个数组中依次取(m+n)/2个数来得到中位数（如果m+n为偶数需要多取一次），实现比较简单，直接看下面代码即可：

代码如下：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        n1 = nums1.size();
        n2 = nums2.size();
        int total = n1 + n2;
        if(total % 2 == 0){
            int times = total/2, res1, res2;
            for(int i = 0; i < times; i++){
                res1 = getNum(nums1, nums2);
            }
            res2 = getNum(nums1, nums2);
            return (res1+res2)/2.0;
        } else {
            int times = total/2+1, res;
            for(int i = 0; i < times; i++){
                res = getNum(nums1, nums2);
            }
            return res;
        }
    }
    
    int getNum(vector<int>& nums1, vector<int>& nums2){
        int a = id1+1, b = id2+1;
        if(a <= (n1-1) && b <= (n2-1)){
            if(nums1[a] < nums2[b]){
                return nums1[++id1];
            } else {
                return nums2[++id2];
            }
        } else if(a <= (n1-1)){
            return nums1[++id1];
        } else if(b <= (n2-1)) {
            return nums2[++id2];
        }
    }
private:
    int id1 = -1;
    int id2 = -1;
    int n1, n2;
};

运行结果如下，该方法的时间复杂度为O(m+n).

解法2

利用经典Top K问题，这里的中位数实际上就是K取一个特定值而已。
在Top K问题中，有一个Cut（割）的概念，即对一个数组进行一次Cut，切割之后的左边部分最大值为L，右边部分最小值为R；可以对两个元素中间进行切割，也可以对一个元素进行切割（此时该元素即属于左边部分也属于右边部分）。

这里对数组进行了扩充，举个例子：
[1,2,3] 扩充后为 [#,1,#,2,#,3,#]
这么做的好处是，不管奇数还是偶数个数的数组，扩充后都变成奇数个数，这样就可以用统一的方法计算。
假设数组nums1，扩充之后虚拟数组个数为2n+1，数组nums2扩充之后虚拟数组个数为2m+1。扩充之后，Li = nums[(Ci-1)/2]；Ri = nums[Ci/2];

对于两个数组，我们可以对两个数组分别在Ci，Cj位置切割，使得第一个数组切割后的左边部分元素个数，加上第二个数组切割后左边部分元素个数等于K。如果L1<=R2且L2<=R1, 则切割是满足要求的，如果求Top K的值则为Max(L1, L2)，该题目求的是中位数，则对应的结果为(Max(L1, L2) + Min(R1, R2))/2.0。如果L1 > R2，说明Ci切割太靠右导致L1太大了，这时应该减小Ci的值；如果L2 > R1，则说明Ci切割太靠左导致R1太小了，这时应该增大Ci的值。

为了寻找一个合适的Ci的值（Cj的值可以通过Ci来确定），同时题目要求时间复杂度为O(log(n+m))，采用二分擦查找来确定Ci的值。即一开始Ci的上下界分别为0和2n，Ci取中间值，如果发现Ci太大，则将上界设为当前Ci-1；Ci太小则将下界设为当前Ci+1；这样就可以在对数时间内找到合适的Ci切割，从而可以求出中间值。

最后还需要注意边界问题，比如C1为0，则L1应该为无穷小，C1为2*n，则R1为无穷大（分别对应第一项和最后一项）。

具体代码如下：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        int m = nums2.size();
        if(n > m) return findMedianSortedArrays(nums2, nums1); // 确保nums1为较短的数组
        int lo = 0, hi = 2*n, L1, L2, R1, R2, c1, c2;
        while(lo <= hi){
            c1 = (lo+hi)/2;
            c2 = (n+m)-c1;
            L1 = c1==0?INT_MIN:nums1[(c1-1)/2];
            R1 = c1==2*n?INT_MAX:nums1[c1/2];
            L2 = c2==0?INT_MIN:nums2[(c2-1)/2];
            R2 = c2==2*m?INT_MAX:nums2[c2/2];
            
            if(L1 > R2){
                hi = c1-1;
            } else if(L2 > R1){
                lo = c1+1;
            } else {
                break;
            }
        }
        return (max(L1, L2)+min(R1, R2))/2.0;
    }
};

然而结果执行用时并没有比前面的做法少，，?