2017-3-13 leetcode 4 11 15

ji那天居然早起了，惊呆我了，眼睛有点儿疼，一直流泪。。。。继续保持

==========================================================

leetcode4 Median of Two Sorted Arrays

leetcode11 Container With Most Water

leetcode15 3Sum

==========================================================

4讲的是
给你n个有序数字，再给你m个有序数字，让你找到所有数里面的中位数，要求复杂度O(log(n+m))

我的思路
同时二分两个数组。。。。。

莫名其妙的一写二分就想打人。。。。

好吧，我没什么成型的想法，于是我看了讨论版，看到了一个很不错的算法，是这样的，首先看一下第一个数组是否比第二个短，如果短就交换一下。在第二个数组中随便找个点i，把nums2划分为两部分,[0...i-1],[i...m-1],可以看到前一部分长度为i，后一部分是m-i，这时在nums1里面有个分割点j，让j=(n+m)/2-i,nums1前半部分长度是j，后半部分长度是n-j，且这时候两个数组的前半部分和后半部分元素数目是相同的（或者后半部分比前半部分多一个），如果我们可以找到一个i，切nums1[j-1]<=nums2[i]&&nums1[j]>=nums2[i-1]（保证所有前半部分的数据都大于等于后半部分）,那么我们就顺利的找到了分割点，中位数自然就出来了。这里边界处理需要稍微注意下，i的取值范围是[0...m]，因为nums[m-1]是有效的。

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size(),m=nums2.size();
        if(n<m)return findMedianSortedArrays(nums2,nums1);
        if(m==0){
            if(n&1)return nums1[n>>1];
            else return 1.0*(nums1[n>>1]+nums1[(n>>1)-1])/2;
        }
        int m_left=0,m_right=m,mid=0,i=0,j=(n+m)/2-i;
        while(m_left<=m_right){
            mid=m_left+(m_right-m_left)>>1;
            i=mid,j=(n+m)/2-i;
            if(i<m&&j>0&&nums2[i]<nums1[j-1])m_left=mid+1;
            else if(j<n&&i>0&&nums1[j]<nums2[i-1]&&mid!=0)m_right=mid-1;
            else{
                int max_of_left=max(i==0?INT_MIN:nums2[i-1],j==0?INT_MIN:nums1[j-1]);
                int min_of_right=min(i==m?INT_MAX:nums2[i],j==n?INT_MAX:nums1[j]);
                if((n+m)&1){
                    return min_of_right;
                }else{
                    return 1.0*(max_of_left+min_of_right)/2;
                }
            }
        }
        return 0;
    }
};

这段代码理论AC就是过不了，居然会超时。。。你们可以看出来问题在哪儿吗？（AC代码见下）

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size(),m=nums2.size();
        if(n<m)return findMedianSortedArrays(nums2,nums1);
        if(m==0){
            if(n&1)return nums1[n>>1];
            else return 1.0*(nums1[n>>1]+nums1[(n>>1)-1])/2;
        }
        int m_left=0,m_right=m,mid=0,i=0,j=(n+m)/2-i;
        while(m_left<=m_right){
            mid=m_left+((m_right-m_left)>>1);//注意右移的优先级低于加号。。。不加括号会爆炸。。。
            i=mid,j=(n+m)/2-i;
            if(i<m&&j>0&&nums2[i]<nums1[j-1])m_left=mid+1;
            else if(j<n&&i>0&&nums1[j]<nums2[i-1]&&mid!=0)m_right=mid-1;
            else{
                int max_of_left=max(i==0?INT_MIN:nums2[i-1],j==0?INT_MIN:nums1[j-1]);
                int min_of_right=min(i==m?INT_MAX:nums2[i],j==n?INT_MAX:nums1[j]);
                if((n+m)&1){
                    return min_of_right;
                }else{
                    return 1.0*(max_of_left+min_of_right)/2;
                }
            }
        }
        return 0;
    }
};

醉了醉了。。。。。

刚刚算法的复杂度是O(log(min(n,m)))的，这道题还有另一种思路，复杂度是O(log(n+m))的。

我们只需要在两个数组中找到大小为第(n+m)/2的元素就可以，于是我们成块的舍弃数据，让两个数组的容量和二分逼近(n+m)/2，看代码。

class Solution {
public:
    int getkth(int s[], int m, int l[], int n, int k){
        // let m <= n
        if (m > n) 
            return getkth(l, n, s, m, k);
        if (m == 0)
            return l[k - 1];
        if (k == 1)
            return min(s[0], l[0]);

        int i = min(m, k / 2), j = min(n, k / 2);
        if (s[i - 1] > l[j - 1])
            return getkth(s, m, l + j, n - j, k - j);
        else
            return getkth(s + i, m - i, l, n, k - i);
        return 0;
    }
    
    double findMedianSortedArrays(int A[], int m, int B[], int n) {
        int l = (m + n + 1) >> 1;
        int r = (m + n + 2) >> 1;
        return (getkth(A, m ,B, n, l) + getkth(A, m, B, n, r)) / 2.0;
    }
};

这段代码不能直接提交，因为C++要求传入的参数是vector<int>，但是他传入的是数组，不太清楚vector有没有O(1)舍弃大块连续数据的方法，否则没有意义，因为只是舍弃数据就会达到O(n)23333

先抛开这道题目的思路不说，当时如果静心拿笔写写很快就可以发现诀窍，没什么好说的。
这里说说二分的写法，十个二分九个错，不知道别人如何，我个人是十分恐惧写二分的，今天看到一句挺好的话“永远保证一端是可行解，另一端是不可行解，就不会出问题”（其实这个是保证答案一定在区间[l,r)中）

另一种叫循环不变式，保证答案一定在区间[l,r]中

int l = 0,r = n-1;    // x 必然存在于区间 [0,n-1] 内。(这里使用闭区间表示)
while( r-l+1 > 1 )     // 只要区间的长度大于1，就继续细分这个区间
{
    // 循环不变式 : x 在区间 [l,r] 内。
    int m = (l+r+1)/2;    // 这里涉及到应该上取整还是下取整的问题
    if( x < v[m] )
        r = m-1;    // x 在区间 [l,m-1] 内
    else
        l = m;        // x 在区间 [r,m] 内
}

//作者：匿名用户
//链接：https://www.zhihu.com/question/36132386/answer/66207613
//来源：知乎
//著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

==========================================================

 11讲的是
给你n个数字作为高度，顺序的排在坐标轴上，取其中两个高度建墙，问你最多能储存多少水。

我的思路
一开始以为是DP之类的，不过感觉没什么规律，后来想到一个贪心的策略，就是从两边往中间逼近，哪边低哪边前进，证明也不难，如果l比较低，但是l不前进，r不管怎么前进，都不可能取到比当时更大的面积了，r作为一个端点限制了水面的高度。

class Solution {
public:
    int maxArea(vector<int>& height) {
        int l=0,r=height.size()-1,ans=0;
        while(l!=r){
            ans=max(ans,(r-l)*min(height[l],height[r]));
            if(height[l]<height[r])l++;
            else r--;
        }
        return ans;
    }
};

==========================================================

15讲的是
给你n个数，输出所有任选3个之和为0的组合。

我的思路
hash记录每个元素，然后双重循环枚举两个元素，判断第三个元素是否存在，O(n^2)
为了避免重复计数，先O(nlogn)排序一下好了。。。

class Solution {
public:
    vector<vector<int> > threeSum(vector<int>& nums) {
        int n=nums.size();
        vector<vector<int> > aim;
        sort(nums.begin(),nums.end(),less<int>());
        unordered_map<int,int> m;
        for(int i=0;i<n;i++)
            m[nums[i]]=i;
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(m.find(-(nums[i]+nums[j]))!=m.end()){
                    if(m[-(nums[i]+nums[j])]>j){
                        vector<int> temp;
                        temp.push_back(nums[i]);
                        temp.push_back(nums[j]);
                        temp.push_back(-(nums[i]+nums[j]));
                        aim.push_back(temp);
                    }
                }
                while(j<n-1&&nums[j+1]==nums[j])j++;
            }
            while(i<n-1&&nums[i+1]==nums[i])i++;
        }
        return aim;
    }
};

 发现自己只击败了4%。。。。。。