962_Maximum_Width_Ramp

Author: qiyuangong

README.md

@@ -205,6 +205,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 953 | [Verifying an Alien Dictionary](https://leetcode.com/contest/weekly-contest-114/problems/verifying-an-alien-dictionary/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/953_Verifying_an_Alien_Dictionary.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/953_Verifying_an_Alien_Dictionary.java) | Use hashmap to store index of each value, then create a comparator based on this index, O(n) and O(n) |
 | 954 | [Array of Doubled Pairs](https://leetcode.com/contest/weekly-contest-114/problems/array-of-doubled-pairs/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/954_Array_of_Doubled_Pairs.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/954_Array_of_Doubled_Pairs.java) | Sort, then use hashmap to store the frequency of each value. Then, check n, 2 * n in hashmap, O(nlogn) and O(n) |
 | 961 | [N-Repeated Element in Size 2N Array](https://leetcode.com/problems/n-repeated-element-in-size-2n-array/submissions/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/961_N-Repeated_Element_in_Size_2N_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/961_N-Repeated_Element_in_Size_2N_Array.java) | Hash and count number, O(n) and O(n) |
+| 962 | [Maximum Width Ramp](https://leetcode.com/problems/maximum-width-ramp/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/962_Maximum_Width_Ramp.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/962_Maximum_Width_Ramp.java) | 1. Sort index by value, then transfer problem into finding max gap between index, O(nlogn) and O(1)<br> |
 
 | # | To Understand |
 |---| ----- |

java/962_Maximum_Width_Ramp.java

@@ -0,0 +1,48 @@
+import java.awt.Point;
+class Solution {
+    public int maxWidthRamp(int[] A) {
+        int N = A.length;
+        Integer[] B = new Integer[N];
+        for (int i = 0; i < N; ++i)
+            B[i] = i;
+        // Sort index based on value
+        Arrays.sort(B, (i, j) -> ((Integer) A[i]).compareTo(A[j]));
+
+        int ans = 0;
+        int m = N;
+        for (int i: B) {
+            ans = Math.max(ans, i - m);
+            m = Math.min(m, i);
+        }
+        return ans;
+    }
+
+    /*public int maxWidthRamp(int[] A) {
+        int N = A.length;
+
+        int ans = 0;
+        List<Point> candidates = new ArrayList();
+        candidates.add(new Point(A[N-1], N-1));
+
+        // candidates: i's decreasing, by increasing value of A[i]
+        for (int i = N-2; i >= 0; --i) {
+            // Find largest j in candidates with A[j] >= A[i]
+            int lo = 0, hi = candidates.size();
+            while (lo < hi) {
+                int mi = lo + (hi - lo) / 2;
+                if (candidates.get(mi).x < A[i])
+                    lo = mi + 1;
+                else
+                    hi = mi;
+            }
+            if (lo < candidates.size()) {
+                int j = candidates.get(lo).y;
+                ans = Math.max(ans, j - i);
+            } else {
+                candidates.add(new Point(A[i], i));
+            }
+        }
+        return ans;
+    }*/
+
+}

python/962_Maximum_Width_Ramp.py

@@ -0,0 +1,46 @@
+class Solution(object):
+    # def maxWidthRamp(self, A):
+    #     """
+    #     :type A: List[int]
+    #     :rtype: int
+    #     """
+    #     # TLE
+    #     if not A or len(A) == 0:
+    #         return 0
+    #     for ans in range(len(A) - 1, 0, -1):
+    #         for i in range(len(A)):
+    #             if i + ans > len(A) - 1:
+    #                 break
+    #             if (A[i + ans] >= A[i]):
+    #                 return ans
+    #     return 0
+
+    def maxWidthRamp(self, A):
+        ans = 0
+        m = float('inf')
+        # Sort index based on value
+        for i in sorted(range(len(A)), key=A.__getitem__):
+            ans = max(ans, i - m)
+            m = min(m, i)
+        return ans
+
+
+    # def maxWidthRamp(self, A):
+    #     N = len(A)
+    #     ans = 0
+    #     candidates = [(A[N - 1], N - 1)]
+    #     # candidates: i's decreasing, by increasing value of A[i]
+    #     for i in xrange(N - 2, -1, -1):
+    #         # Find largest j in candidates with A[j] >= A[i]
+    #         jx = bisect.bisect(candidates, (A[i],))
+    #         if jx < len(candidates):
+    #             ans = max(ans, candidates[jx][1] - i)
+    #         else:
+    #             candidates.append((A[i], i))
+    #     return ans
+
+
+if __name__ == '__main__':
+    s = Solution()
+    print s.maxWidthRamp([6, 0, 8, 2, 1, 5])
+    print s.maxWidthRamp([9, 8, 1, 0, 1, 9, 4, 0, 4, 1])