search 2D matrix

Author: JoshuaJiangFD

src/main/java/joshua/leetcode/array/binarysearch/Search2DMatrix.java

@@ -0,0 +1,85 @@
+package joshua.leetcode.array.binarysearch;
+
+import joshua.leetcode.solutiontag.*;
+import joshua.leetcode.solutiontag.BinarySearch;
+
+/**
+ * 74. Search a 2D Matrix<br/>
+ * <p/>
+ * <a href ="https://leetcode.com/problems/search-a-2d-matrix/">leetcode link</a>
+ *
+ * @author Joshua.Jiang on 2016/5/29.
+ */
+public abstract class Search2DMatrix {
+
+    /**
+     * Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:
+     * <p/>
+     * 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.
+     * <p/>
+     * <p/>
+     * For example,
+     * Consider the following matrix:
+     * <p/>
+     * [
+     * [1,   3,  5,  7],
+     * [10, 11, 16, 20],
+     * [23, 30, 34, 50]
+     * ]
+     * <p/>
+     * Given target = 3, return true
+     *
+     * @param matrix
+     * @param target
+     * @return
+     */
+    public abstract boolean searchMatrix(int[][] matrix, int target);
+
+
+    /**
+     * 先根据最后一列确定在哪一行，再对该行做binary search
+     */
+    @BinarySearch
+    public static class Solution1 extends Search2DMatrix {
+
+        @Override
+        public boolean searchMatrix(int[][] matrix, int target) {
+            if (matrix == null || matrix[0] == null || matrix[0].length == 0) {
+                return false;
+            }
+            int row = matrix.length;
+            int col = matrix[0].length;
+            // first binary search
+            int beg = 0, end = row - 1;
+            while (beg <= end) {
+                int mid = (beg + end) / 2;
+                if (matrix[mid][col - 1] > target) {
+                    end = mid - 1;
+                } else if (matrix[mid][col - 1] < target) {
+                    beg = mid + 1;
+                } else {
+                    return true;
+                }
+            }
+            //boundary case, for example if target is 70 in the above example.
+            if (beg == row) {
+                return false;
+            }
+            //now need to search row indexed by 'beg'
+            int rowBeg = 0, rowEnd = col - 1;
+            while (rowBeg <= rowEnd) {
+                int rowMid = (rowBeg + rowEnd) / 2;
+                if(matrix[beg][rowMid] == target) {
+                    return true;
+                }
+                if (matrix[beg][rowMid] < target) {
+                    rowBeg = rowMid + 1;
+                } else {
+                    rowEnd = rowMid - 1;
+                }
+            }
+            return false;
+        }
+    }
+}

src/main/java/joshua/leetcode/divideconquer/KthLargestElementInArray.java

@@ -1,5 +1,7 @@
 package joshua.leetcode.divideconquer;
 
+import joshua.leetcode.solutiontag.MinHeap;
+
 /**
  * Kth Largest Element in an Array
  *
@@ -25,6 +27,7 @@ public abstract class KthLargestElementInArray {
 
     /**
      * Divide and Conquer way.
+     *
      * partition the array using quick-sorting way(descending sort), every pass find the final position of an element.
      * If this position's index is bigger than k-1, quick sort the partition on left, otherwise right.
      * function returns if position is found at index k-1.
@@ -71,6 +74,7 @@ private int partition(int[] nums, int start, int end) {
      *
      * @author joy
      */
+    @MinHeap
     static class Solution2 extends KthLargestElementInArray {
 
         @Override

src/main/java/joshua/leetcode/divideconquer/Search2DMatrixII.java

@@ -0,0 +1,48 @@
+package joshua.leetcode.divideconquer;
+
+/**
+ * 240. Search a 2D Matrix II<br/>
+ * <a href = "https://leetcode.com/problems/search-a-2d-matrix-ii/">leetcode link</a>
+ *
+ * @author Joshua.Jiang on 2016/5/29.
+ */
+public abstract class Search2DMatrixII {
+
+    /**
+     * Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties:
+     * <ul>
+     * <li>Integers in each row are sorted in ascending from left to right.</li>
+     * <li>Integers in each column are sorted in ascending from top to bottom.</li>
+     * For example,
+     * </ul>
+     * Consider the following matrix:
+     * <p/>
+     * [<br/>
+     * [1,   4,  7, 11, 15],<br/>
+     * [2,   5,  8, 12, 19],<br/>
+     * [3,   6,  9, 16, 22],<br/>
+     * [10, 13, 14, 17, 24],<br/>
+     * [18, 21, 23, 26, 30]<br/>
+     * ]<br/>
+     * Given target = 5, return true.
+     * Given target = 20, return false.
+     *
+     * @param matrix
+     * @param target
+     * @return
+     */
+    public abstract boolean searchMatrix(int[][] matrix, int target);
+
+    /**
+     *  观察矩阵可以发现， 每个对角线上的元素matrix[i,i]都大于所有其他index小于i的元素，即该元素的左上角的矩阵。
+     *  因此可以先对对角线上元素做二分查找。
+     *
+     */
+    public static class Solution1 extends Search2DMatrixII {
+
+        @Override
+        public boolean searchMatrix(int[][] matrix, int target) {
+
+        }
+    }
+}

src/main/java/joshua/leetcode/solutiontag/BinarySearch.java

@@ -0,0 +1,7 @@
+package joshua.leetcode.solutiontag;
+
+/**
+ * @author Joshua.Jiang on 2016/5/29.
+ */
+public @interface BinarySearch {
+}

src/test/java/joshua/leetcode/array/binarysearch/Search2DMatrixTest.java

@@ -0,0 +1,35 @@
+package joshua.leetcode.array.binarysearch;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class Search2DMatrixTest {
+
+    private Search2DMatrix solution;
+
+    @Before
+    public void setUp() {
+        solution = new Search2DMatrix.Solution1();
+    }
+
+    @Test
+    public void testSolution() {
+        int[][] matrix = new int[][]{
+                {1, 3, 5, 7},
+                {10, 11, 16, 20},
+                {23, 30, 34, 50}
+        };
+        assertTrue(solution.searchMatrix(matrix, 7));
+        assertTrue(solution.searchMatrix(matrix, 3));
+        assertTrue(solution.searchMatrix(matrix, 30));
+        assertTrue(solution.searchMatrix(matrix, 50));
+
+        assertFalse(solution.searchMatrix(matrix, -1));
+        assertFalse(solution.searchMatrix(matrix, 8));
+        assertFalse(solution.searchMatrix(matrix, 70));
+    }
+
+
+}