1D

1D

Author: dandanhub

Array/1D.md

@@ -308,6 +308,72 @@ public class Solution {
 }
 ~~~
 
+## 456. 132 Pattern
+Given a sequence of n integers a1, a2, ..., an, a 132 pattern is a subsequence ai, aj, ak such that i < j < k and ai < ak < aj. Design an algorithm that takes a list of n numbers as input and checks whether there is a 132 pattern in the list.
+
+Note: n will be less than 15,000.
+
+Example 1:
+~~~
+Input: [1, 2, 3, 4]
+
+Output: False
+
+Explanation: There is no 132 pattern in the sequence.
+~~~
+Example 2:
+~~~
+Input: [3, 1, 4, 2]
+
+Output: True
+
+Explanation: There is a 132 pattern in the sequence: [1, 4, 2].
+~~~
+Example 3:
+~~~
+Input: [-1, 3, 2, 0]
+
+Output: True
+
+Explanation: There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
+~~~
+
+#### Solution
+1. O(n^2) method : fix j, find min from range(0, j - 1), check whether in range(j + 1, nums.length - 1) has a number less than nums[j] and greater than min.
+2. O(n) method : using stack.  
+
+Method 1 O(n^2) <br>
+Attempt: 1
+~~~
+public class Solution {
+    public boolean find132pattern(int[] nums) {
+        if (nums == null || nums.length < 3) return false;
+
+        // fix j
+        for (int j = 1; j < nums.length - 1; j++) {
+            // find min num in range from 0 to j - 1, and make it as i
+            int min = nums[0];
+            // int index = 0; // no need to track index
+            for (int i = 1; i < j; i++) {
+                if (nums[i] < min) {
+                    min = nums[i];
+                    // index = i;
+                }
+            }
+
+            // found a valid i
+            if (min < nums[j]) {
+                // find k in range from j + 1 to nums.length - 1
+                for (int k = j + 1; k < nums.length; k++) {
+                    if (nums[k] < nums[j] && nums[k] > min) return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}
+~~~
 ## 18. 4Sum (Medium)
 Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.
 
@@ -462,7 +528,7 @@ Given n non-negative integers a1, a2, ..., an, where each represents a point at
 Note: You may not slant the container and n is at least 2.
 
 #### Solution
-Two pointers
+Two pointers <br>
 Old version of code will get TLE with new leetcode test code.
 How to improve?
 
@@ -701,6 +767,44 @@ public class Solution {
 ~~~
 
 # Binary Search
+## 287. Find the Duplicate Number
+Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.
+
+Note:
+1. You must not modify the array (assume the array is read only).
+2. You must use only constant, O(1) extra space.
+3. Your runtime complexity should be less than O(n2).
+4. There is only one duplicate number in the array, but it could be repeated more than once.
+
+#### Solution
+题目限定只有一个重复的数字让问题变得简单
+
+Attempt: 2 (bug when counting)
+~~~
+public class Solution {
+    public int findDuplicate(int[] nums) {
+        if (nums == null || nums.length == 0) return 0;
+        int l = 1;
+        int r = nums.length - 1;
+        while (l < r) {
+            int m = (r - l) / 2 + l;
+            int count = 0;
+            for (int i = 0; i < nums.length; i++) {
+                // if (nums[i] <= m) count++; // bug
+                if (nums[i] >= l && nums[i] <= m) count++;
+            }
+            if (count > m - l + 1) {
+                r = m;
+            }
+            else {
+                l = m + 1;
+            }
+        }
+        return l;
+    }
+}
+~~~
+
 ## 4. Median of Two Sorted Arrays (Hard) *
 There are two sorted arrays nums1 and nums2 of size m and n respectively.
 

Array/2D.md

@@ -706,3 +706,214 @@ public class NumMatrix {
  * int param_2 = obj.sumRegion(row1,col1,row2,col2);
  */
 ~~~
+
+# Binary Search
+## 74. Search a 2D Matrix
+Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:
+
+Integers in each row are sorted from left to right.
+The first integer of each row is greater than the last integer of the previous row.
+For example,
+
+Consider the following matrix:
+~~~
+[
+  [1,   3,  5,  7],
+  [10, 11, 16, 20],
+  [23, 30, 34, 50]
+]
+~~~
+Given target = 3, return true.
+
+#### Solution
+
+Attempt: 3 <br>
+bug 1: 输入是matrix, 粗心用了nums
+bug 2: 在转换成[][]的时候 [m / w][m % w]，粗心用了h
+bug 3: 传统的二分查找结束的条件是l <= r
+~~~
+public class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+        int h = matrix.length;
+        int w = matrix[0].length;
+        int l = 0;
+        int r = h * w - 1;
+        while (l <= r) {
+            int m = (r - l) / 2 + l;
+            if (target == matrix[m / w][m % w]) return true;
+            else if (target > matrix[m / w][m % w]) l = m + 1;
+            else r = m - 1;
+        }
+        return false;
+    }
+}
+~~~
+
+## 240. Search a 2D Matrix II (Optimal Solution not BS)
+Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:
+
+Integers in each row are sorted in ascending from left to right.
+Integers in each column are sorted in ascending from top to bottom.
+For example,
+
+Consider the following matrix:
+~~~
+[
+  [1,   4,  7, 11, 15],
+  [2,   5,  8, 12, 19],
+  [3,   6,  9, 16, 22],
+  [10, 13, 14, 17, 24],
+  [18, 21, 23, 26, 30]
+]
+~~~
+Given target = 5, return true.
+
+Given target = 20, return false.
+
+#### Solution
+1. Naiive way is to do binary search in each row, time O(nlogm)
+2. 从右上角开始比较，if (target > matrix[row][col]) row++; else col--;
+
+~~~
+public class Solution {
+    public boolean searchMatrix(int[][] matrix, int target) {
+        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
+        int h = matrix.length;
+        int w = matrix[0].length;
+
+        int row = 0;
+        int col = w - 1;
+        while (row < h && col >= 0) {
+            if (target == matrix[row][col]) return true;
+            else if (target > matrix[row][col]) {
+                row++;
+            }
+            else {
+                col--;
+            }
+        }
+        return false;
+    }
+}
+~~~
+
+## 378. Kth Smallest Element in a Sorted Matrix
+Given a n x n matrix where each of the rows and columns are sorted in ascending order, find the kth smallest element in the matrix.
+
+Note that it is the kth smallest element in the sorted order, not the kth distinct element.
+
+Example:
+
+matrix = [
+   [ 1,  5,  9],
+   [10, 11, 13],
+   [12, 13, 15]
+],
+k = 8,
+
+return 13.
+Note:
+You may assume k is always valid, 1 ≤ k ≤ n2.
+
+#### Solution
+1. 暴力破解，Use max heap maintaining size of K, time O(mnlogk), space O(k), m is matrix height n is matrix width. 完全没有利用到sorted matrix的特点。
+2. 类似于 Merge K Sorted Array, 利用了matrix每一个row都sorted的特点，但是没有利用matrix每一个col都sorted的特点, time O(klogm)
+3. Binary search, 去左上角为最小值，右下角为最大值，O((m+n)log(max-min)), 在查找每一行最mid小的col的时候可以用二分，则复杂度是O(mlognlog(max-min)), log(max-min)最坏情况下为32.
+
+1 O(mnlogk) 37ms
+~~~
+public class Solution {
+    public int kthSmallest(int[][] matrix, int k) {
+        // if (matrix == null || matrix.length == 0 || matrix[0].length == 0)
+        PriorityQueue<Integer> pq = new PriorityQueue<Integer>(k, Collections.reverseOrder());
+        for (int i = 0; i < matrix.length; i++) {
+            for (int j = 0; j < matrix[0].length; j++) {
+                if (pq.size() < k) pq.offer(matrix[i][j]);
+                else if (pq.size() == k && matrix[i][j] < pq.peek()) {
+                    pq.poll();
+                    pq.offer(matrix[i][j]);
+                }
+            }
+        }
+        return pq.poll();
+    }
+}
+~~~
+
+2 28ms
+~~~
+public class Solution {
+    class Num {
+        int value;
+        int row;
+        int col;
+
+        public Num(int value, int row, int col){
+            this.value = value;
+            this.row = row;
+            this.col = col;
+        }
+    }
+
+    public int kthSmallest(int[][] matrix, int k) {
+        PriorityQueue<Num> pq = new PriorityQueue<Num>(new Comparator<Num>() {
+            public int compare(Num n1, Num n2) {
+                return n1.value - n2.value;
+            }
+        });
+
+        int m = matrix.length;
+        int n = matrix[0].length;
+        for (int i = 0; i < m; i++) {
+            pq.offer(new Num(matrix[i][0], i, 0));
+        }
+
+        Num smallest = null;
+        while (k > 0) {
+            smallest = pq.poll();
+            k--;
+            int row = smallest.row;
+            int col = smallest.col + 1;
+            if (col < n) {
+                Num next = new Num(matrix[row][col], row, col);
+                pq.offer(next);
+            }
+        }
+
+        // exception
+        // if (smallest == null)
+
+        return smallest.value;       
+    }
+}
+~~~
+
+3 1ms
+~~~
+public class Solution {
+    public int kthSmallest(int[][] matrix, int k) {
+        int h = matrix.length;
+        int w = matrix[0].length;
+        int low = matrix[0][0];
+        int high = matrix[h - 1][w - 1];
+        while (low < high) {
+            int mid = (high - low) / 2 + low;
+            int j = w - 1;
+            int count = 0;
+            for (int i = 0; i < h; i++) {
+                while (j >= 0 && matrix[i][j] > mid) j--;
+                count += j + 1;
+            }
+
+            if (count >= k) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+}
+~~~

Array/Sort.md

@@ -0,0 +1,51 @@
+## 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.
+
+Note:
+You may assume k is always valid, 1 ≤ k ≤ array's length.
+
+#### Solution
+用Quick Sort来分段，选取pivot元素，一次quick sort后pivot左边的都小于pivot, 右边的都大于pivot, 然后每次丢弃一半的元素
+1. average, O(n)
+2. worst case O(n^2)
+
+~~~
+public class Solution {
+    public int findKthLargest(int[] nums, int k) {
+        return quickPartition(nums, 0, nums.length - 1, nums.length - k);
+    }
+
+    public int quickPartition(int[] nums, int start, int end, int k) {
+        int pivot = end;
+        int left = start;
+
+        for (int i = start; i < end; i++) {
+            if (nums[i] <= nums[pivot]) {
+                swap(nums, i, left);
+                left++;
+            }
+        }
+        swap(nums, left, pivot);
+        pivot = left;
+
+        if (k == pivot) return nums[pivot];
+        else if (k > pivot) {
+            quickPartition(nums, pivot + 1, end, k);
+        }
+        else {
+            quickPartition(nums, start, pivot - 1, k);
+        }
+        return Integer.MAX_VALUE;
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+~~~