update

Author: anson627

ContainerWithMostWater/ContainerWithMostWater.cpp

@@ -19,16 +19,14 @@ using namespace std;
 class Solution {
 public:
     int maxArea(vector<int> &height) {
-        int N = height.size();
-        if (N < 2) return 0;
-        int i = 0, j = N-1, res = 0;
+        int i = 0, j = height.size() - 1, res = 0;
         while (i < j) {
-            res = max(res, (j-i)*min(height[i], height[j]));
-            if (height[i] < height[j]) {
-                do { i++; } while (i < j && height[i] <= h);
+            res = max(res, min(height[i], height[j])*(j - i));
+            if (height[i] <= height[j]) {
+                do { i++; } while (i < j && height[i] <= height[i - 1]);
             }
             else {
-                do { j--; } while (i < j && height[j] <= h);
+                do { j--; } while (i < j && height[j] <= height[j + 1]);
             }
         }
         return res;

MedianofTwoSortedArrays/MedianofTwoSortedArrays.cpp

@@ -11,36 +11,38 @@ using namespace std;
 class Solution {
 public:
     double findMedianSortedArrays(int A[], int m, int B[], int n) {
-        if (m == 0 && n == 0) return 0.0;
         return findMedianSortedArrays2(A, m, B, n);
     }
 
     double findMedianSortedArrays1(int A[], int m, int B[], int n) {
-        int i = 0, j = 0, m1 = -1, m2 = -1;
-        for (int k = 0; k <= (m+n)/2; k++) {
-            m1 = m2;
-            if (j == n || (i < m && A[i] < B[j])) m2 = A[i++];
-            else m2 = B[j++];
+        int r1 = -1, r2 = -1, i = 0, j = 0;
+        for (int k = (m + n) / 2; k >= 0; k--) {
+            r1 = r2;
+            if (j == n || (i < m && A[i] <= B[j])) r2 = A[i++];
+            else r2 = B[j++];
         }
-
-        if ((m+n)%2) return (double)m2;
-        return (m1+m2)/2.0;
+        if ((m + n) % 2) return (double)r2;
+        return (r1 + r2) / 2.0;
     }
 
     double findMedianSortedArrays2(int A[], int m, int B[], int n) {
-        if ((m+n)%2) return (double)findKth(A, m, B, n, (m+n)/2+1);
-        return (findKth(A, m, B, n, (m+n)/2)+findKth(A, m, B, n, (m+n)/2+1))/2.0;
+        int k = (m + n) / 2;
+        if ((m + n) % 2) return findKth(A, m, B, n, k + 1);
+        return (findKth(A, m, B, n, k) + findKth(A, m, B, n, k + 1)) / 2.0;
     }
 
     int findKth(int A[], int m, int B[], int n, int k) {
-        if (m > n) return findKth(B, n, A, m, k);
-        if (m == 0) return B[k-1];
+        if (n == 0) return A[k - 1];
+        if (m == 0) return B[k - 1];
         if (k == 1) return min(A[0], B[0]);
-
-        int p1 = min(k/2, m), p2 = k-p1;
-        if (A[p1-1] < B[p2-1]) return findKth(A+p1, m-p1, B, n, k-p1);
-        if (A[p1-1] > B[p2-1]) return findKth(A, m, B+p2, n-p2, k-p2);
-        return A[p1-1];
+        if (m / 2 + n / 2 + 1 >= k) {
+            if (A[m / 2] <= B[n / 2]) return findKth(A, m, B, n / 2, k);
+            else return findKth(A, m / 2, B, n, k);
+        }
+        else {
+            if (A[m / 2] <= B[n / 2]) findKth(A + m / 2 + 1, m - (m / 2 + 1), B, n, k - (m / 2 + 1));
+            else return findKth(A, m, B + n / 2 + 1, n - (n / 2 + 1), k - (n / 2 + 1));
+        }
     }
 };
 

SearchInsertPosition/SearchInsertPosition.cpp

@@ -28,8 +28,8 @@ class Solution {
             if (A[m] < target) l = m+1;
             else u = m;
         }
-        if (A[l] < target) return n;
-        return l;
+        if (A[u] < target) return n;
+        return u;
     }
 };
 

SearchforaRange/SearchforaRange.cpp

@@ -19,35 +19,33 @@ using namespace std;
 class Solution {
 public:
     vector<int> searchRange(int A[], int n, int target) {
-        int l = lower_bound(A, n, target);
-        int u = upper_bound(A, n, target)-1;
+        int l = lowerBound(A, n, target);
+        int u = upperBound(A, n, target) - 1;
         vector<int> res(2, -1);
-        if (l > u) return res;
-        res[0] = l;
-        res[1] = u;
+        if (l <= u) res[0] = l, res[1] = u;
         return res;
     }
 
-    int lower_bound(int A[], int n, int target) {
-        int l = 0, u = n-1;
+    int lowerBound(int A[], int n, int target) {
+        int l = 0, u = n - 1;
         while (l < u) {
-            int m = l+(u-l)/2;
-            if (A[m] < target) l = m+1;
+            int m = l + (u - l) / 2;
+            if (A[m] < target) l = m + 1;
             else u = m;
         }
-        if (A[l] < target) return n;
-        return l;
+        if (A[u] < target) return n;
+        return u;
     }
 
-    int upper_bound(int A[], int n, int target) {
-        int l = 0, u = n-1;
+    int upperBound(int A[], int n, int target) {
+        int l = 0, u = n - 1;
         while (l < u) {
-            int m = l+(u-l)/2;
-            if (A[m] <= target) l = m+1;
+            int m = l + (u - l) / 2;
+            if (A[m] <= target) l = m + 1;
             else u = m;
         }
-        if (A[l] <= target) return n;
-        return l;
+        if (A[u] <= target) return n;
+        return u;
     }
 };
 

SearchinRotatedSortedArray/SearchinRotatedSortedArray.cpp

@@ -20,17 +20,17 @@ using namespace std;
 class Solution {
 public:
     int search(int A[], int n, int target) {
-        int l = 0, u = n-1;
+        int l = 0, u = n - 1;
         while (l <= u) {
-            int m = l+(u-l)/2;
+            int m = l + (u - l) / 2;
             if (A[m] == target) return m;
-            if (A[l] < A[m]) {
-                if (A[l] <= target && target < A[m]) u = m-1;
-                else l = m+1;
+            if (A[l] <= A[m]) {
+                if (A[l] <= target && target < A[m]) u = m - 1;
+                else l = m + 1;
             }
             else {
-                if (A[m] < target && target <= A[u]) l = m+1;
-                else u = m-1;
+                if (A[m] < target && target <= A[u]) l = m + 1;
+                else u = m - 1;
             }
         }
         return -1;