2017-3-13 leetcode 4 11 15

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

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

leetcode4 Median of Two Sorted Arrays

leetcode11Container With Most Water

leetcode153Sum

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

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==){
             if(n&)return nums1[n>>];
             else return 1.0*(nums1[n>>]+nums1[(n>>)-])/;
         }
         int m_left=,m_right=m,mid=,i=,j=(n+m)/-i;
         while(m_left<=m_right){
             mid=m_left+(m_right-m_left)>>;
             i=mid,j=(n+m)/-i;
             if(i<m&&j>&&nums2[i]<nums1[j-])m_left=mid+;
             else if(j<n&&i>&&nums1[j]<nums2[i-]&&mid!=)m_right=mid-;
             else{
                 int max_of_left=max(i==?INT_MIN:nums2[i-],j==?INT_MIN:nums1[j-]);
                 int min_of_right=min(i==m?INT_MAX:nums2[i],j==n?INT_MAX:nums1[j]);
                 if((n+m)&){
                     return min_of_right;
                 }else{
                     return 1.0*(max_of_left+min_of_right)/;
                 }
             }
         }
         return ;
     }
 };

WA

这段代码理论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==){
             if(n&)return nums1[n>>];
             else return 1.0*(nums1[n>>]+nums1[(n>>)-])/;
         }
         int m_left=,m_right=m,mid=,i=,j=(n+m)/-i;
         while(m_left<=m_right){
             mid=m_left+((m_right-m_left)>>);//注意右移的优先级低于加号。。。不加括号会爆炸。。。
             i=mid,j=(n+m)/-i;
             if(i<m&&j>&&nums2[i]<nums1[j-])m_left=mid+;
             else if(j<n&&i>&&nums1[j]<nums2[i-]&&mid!=)m_right=mid-;
             else{
                 int max_of_left=max(i==?INT_MIN:nums2[i-],j==?INT_MIN:nums1[j-]);
                 int min_of_right=min(i==m?INT_MAX:nums2[i],j==n?INT_MAX:nums1[j]);
                 if((n+m)&){
                     return min_of_right;
                 }else{
                     return 1.0*(max_of_left+min_of_right)/;
                 }
             }
         }
         return ;
     }
 };

AC

醉了醉了。。。。。

刚刚算法的复杂度是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 == )
             return l[k - ];
         if (k == )
             return min(s[], l[]);

         int i = min(m, k / ), j = min(n, k / );
         if (s[i - ] > l[j - ])
             return getkth(s, m, l + j, n - j, k - j);
         else
             return getkth(s + i, m - i, l, n, k - i);
         return ;
     }

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

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

BS

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

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

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

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

11

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

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=;i<n;i++)
             m[nums[i]]=i;
         for(int i=;i<n;i++){
             for(int j=i+;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-&&nums[j+]==nums[j])j++;
             }
             while(i<n-&&nums[i+]==nums[i])i++;
         }
         return aim;
     }
 };

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