add 363

Author: fishercoder1534

README.md

@@ -239,6 +239,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |366|[Find Leaves of Binary Tree](https://leetcode.com/problems/find-leaves-of-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_366.java)| O(n)|O(h) | Medium| DFS
 |365|[Water and Jug Problem](https://leetcode.com/problems/water-and-jug-problem/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_365.java)| O(n)|O(1) | Medium| Math
 |364|[Nested List Weight Sum II](https://leetcode.com/problems/nested-list-weight-sum-ii/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_364.java)| O(n)|O(h) | Medium| DFS
+|363|[Max Sum of Rectangle No Larger Than K](https://leetcode.com/problems/max-sum-of-rectangle-no-larger-than-k/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_363.java)| | | Hard| DP 
 |362|[Design Hit Counter](https://leetcode.com/problems/design-hit-counter/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_362.java)| O(1) amortized|O(k) | Medium| Design
 |361|[Bomb Enemy](https://leetcode.com/problems/bomb-enemy/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_361.java)| O(?)|O(?) | Medium| 
 |360|[Sort Transformed Array](https://leetcode.com/problems/sort-transformed-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_360.java)| O(n)|O(1) | Medium| Two Pointers, Math

src/main/java/com/fishercoder/solutions/_363.java

@@ -0,0 +1,56 @@
+package com.fishercoder.solutions;
+
+import java.util.TreeSet;
+
+/**
+ * 363. Max Sum of Rectangle No Larger Than K
+ *
+ * Given a non-empty 2D matrix matrix and an integer k,
+ * find the max sum of a rectangle in the matrix such that its sum is no larger than k.
+
+ Example:
+ Given matrix = [
+ [1,  0, 1],
+ [0, -2, 3]
+ ]
+ k = 2
+ The answer is 2. Because the sum of rectangle [[0, 1], [-2, 3]] is 2 and 2 is the max number no larger than k (k = 2).
+
+ Note:
+ The rectangle inside the matrix must have an area > 0.
+ What if the number of rows is much larger than the number of columns?
+ */
+public class _363 {
+    /**reference: https://discuss.leetcode.com/topic/48854/java-binary-search-solution-time-complexity-min-m-n-2-max-m-n-log-max-m-n*/
+    public int maxSumSubmatrix(int[][] matrix, int k) {
+        int row = matrix.length;
+        if (row == 0) return 0;
+        int col = matrix[0].length;
+        int m = Math.min(row, col);
+        int n = Math.max(row, col);
+        //indicating sum up in every row or every column
+        boolean colIsBig = col > row;
+        int res = Integer.MIN_VALUE;
+        for (int i = 0; i < m; i++) {
+            int[] array = new int[n];
+            // sum from row j to row i
+            for (int j = i; j >= 0; j--) {
+                int val = 0;
+                TreeSet<Integer> set = new TreeSet<>();
+                set.add(0);
+                //traverse every column/row and sum up
+                for (int p = 0; p < n; p++) {
+                    array[p] = array[p] + (colIsBig ? matrix[j][p] : matrix[p][j]);
+                    val = val + array[p];
+                    //use  TreeMap to binary search previous sum to get possible result
+                    Integer subres = set.ceiling(val - k);
+                    if (null != subres) {
+                        res = Math.max(res, val - subres);
+                    }
+                    set.add(val);
+                }
+            }
+        }
+        return res;
+    }
+}