leetcode-Divide and Conquer

算法系列之分治篇

选题：215. Kth Largest Element 4. Median of Two Sorted Arrays
这两题简单易解，但是均能通过分治的思想将算法复杂度优化

215: Kth Largest Element in an Array

Find the kth largest element in an unsorted array.
Note that it is the kth largest element in the sorted order, not the kth distinct element.
For example,
Given [3,2,1,5,6,4] and k = 2, return 5.

简单解法（此处不再贴出代码）
先对数组进行排序，然后直接得到第K个元素，众所周知，排序算法最优复杂度为O(N*logN)

分治算法   借助快排的思想，将问题分治，步骤如下：
  1.随机选取一个数作为旗帜；
  2.调整数组顺序，使得旗帜左边的数比其大，右边的数比其小（无需降序排列）；
  3.设左部分(旗帜及其左边的数)的长度为L
    a.若K < L，递归地在左部分找第K大的数
    b.若K > L，递归地在有部分中找第(K - L)大的数
    c.若K = L，返回左右两部分的分割点（即旗帜），就是要求的第K大的数。
此时时间复杂度降为O(N*logK)，该思想实现代码如下：

int _findKth(vector<int>& nums, int low, int high, int k) {
    if(k <= 0)  
        return -1;  
    if(k > high - low + 1)  
        return -1;  
    int flag = (low + high) / 2; 
    swap(nums[low], nums[flag]);  
    int m = low;  
    int count = 1; // The num of elements that >= the flag element.

    // Put elements that >= the flag element to the left of the flag element
    for(int i = low + 1; i <= high; ++i) 
        if(nums[i] > nums[low]) {  
            swap(nums[++m], nums[i]);  
            count++;
        }
    swap(nums[m], nums[low]); 

    if(count > k)
        return _findKth(nums, low, m - 1, k);
    else if(count < k)
        return _findKth(nums, m + 1, high, k - count);
    else return nums[m];
}

int findKthLargest(vector<int> nums, int k) {
    return _findKth(nums, 0, nums.size(), k); 
}

4. Median of Two Sorted Arrays

There are two sorted arrays nums1 and nums2 of size m and n respectively. Find the median of the two sorted arrays.

简单解法 （此处不再贴出代码）
最简单易想到的解法就是将借助类似将两个数组合并的思想，分别对两个数组设置指针，依次往后数到中位数的位置，但时间复杂度为O(m+n)

分治算法   进一步将其一般化，实际上就是在两个升序的数组中找出第K小的元素，
只不过这里K=(m+n) / 2；当m+n为偶数的时候，即是找出第(m+n) / 2小和第(m+n) / 2 +1小的两个数求平均值
下面开始着手解决这个问题：
首先取pa=min(k/2, m)，pb=k-pa，比较nums1[pa-1]和nums2[pb-1], 分别表示nums1中第pa小的元素和nums2中第pb小的元素：
    1.如果nums1[pa-1] < nums2[pb-1]，这表示nums1[0~pa]的元素都在nums1和nums2合并之后前k小的元素中，
      因此将这段抛弃，递归地在剩下的数组中找出第k-pa小的元素
    2.如果nums1[pa-1] > nums2[pb-1]，类似将nums2[0~pb]段抛弃，递归地在剩下的数组中找出第k-pb小的元素
    3.如果nums1[pa-1] = nums2[pb-1]，记这个相等的元素为m，由于pa+pb=k，则m即是第k小的元素。
下面考虑其他边界结束条件：
    a.如果nums1或者nums2为空，则直接返回nums2[k-1]或者nums1[k-1]；
    b.如果k为1，我们只需要返回nums1[0]和nums2[0]中的较小值；

很容易可以看出，平均情况下每次都有k一半的元素被删除，所以算法复杂度为logk，由于求中位数时k为（m+n）/2，所以算法复杂度为log(m+n)。

double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
    if (nums1.size() > nums2.size())
        return findMedianSortedArrays(nums2, nums1);

    int total = nums1.size() + nums2.size();
    if (total & 1) { // 利用位运算判断奇偶
        if (nums1.size() == 0)
            return nums2[total / 2];
        return findKth(&nums1[0], nums1.size(), &nums2[0], nums2.size(), total / 2 + 1);
    } else {
        if (nums1.size() == 0)
            return (nums2[total / 2 - 1] + nums2[total / 2]) / 2.0;
        return (findKth(&nums1[0], nums1.size(), &nums2[0], nums2.size(), total / 2)  
                + findKth(&nums1[0], nums1.size(), &nums2[0], nums2.size(), total / 2 + 1)) / 2.0; 
    }

}

double findKth(int nums1[], int m, int nums2[], int n, int k) { 
    if (m == 0)
        return nums2[k - 1];  
    if (k == 1)
        return min(nums1[0], nums2[0]);  

    int pa = min(k / 2, m), pb = k - pa;  
    if (nums1[pa - 1] < nums2[pb - 1])  
        return findKth(nums1 + pa, m - pa, nums2, n, k - pa);  
    else if (nums1[pa - 1] > nums2[pb - 1])  
        return findKth(nums1, m, nums2 + pb, n - pb, k - pb);  
    else  
        return nums1[pa - 1]; 
}