add 1439

Author: fishercoder1534

README.md

@@ -269,6 +269,7 @@ _If you like this project, please leave me a star._ ★
 |1447|[Simplified Fractions](https://leetcode.com/problems/simplified-fractions/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1447.java) | |Medium|Math|
 |1446|[Consecutive Characters](https://leetcode.com/problems/consecutive-characters/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1446.java) | |Easy|String|
 |1441|[Build an Array With Stack Operations](https://leetcode.com/problems/build-an-array-with-stack-operations/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1441.java) | |Easy|Stack|
+|1439|[Find the Kth Smallest Sum of a Matrix With Sorted Rows](https://leetcode.com/problems/find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1439.java) | |Hard|Array, Binary Search, PriorityQueue, Matrix|
 |1437|[Check If All 1's Are at Least Length K Places Away](https://leetcode.com/problems/check-if-all-1s-are-at-least-length-k-places-away/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1437.java) | |Medium|Array|
 |1436|[Destination City](https://leetcode.com/problems/destination-city/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1436.java) | |Easy|String|
 |1432|[Max Difference You Can Get From Changing an Integer](https://leetcode.com/problems/max-difference-you-can-get-from-changing-an-integer/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_1432.java) | |Medium|String|

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

@@ -0,0 +1,62 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.TreeSet;
+
+public class _1439 {
+    public static class Solution1 {
+        /**
+         * My completely own implementation after reading the hint on LeetCode:
+         * 1. We put the sum along with every single element's index in each row as an array into a TreeSet, let it sort by its sum ascendingly;
+         * each time we poll an element out of the set, we can find the next m smallest sums by moving each row index to the right by one.
+         * 2. priority queue doesn't help in this case unless used in combination with a set to filter out duplicates;
+         * 3. implement a customized comparator for treeset: if sum i.e. entry[0] doesn't equal, then it's not a duplicate,
+         * then we compare the rest of the elements in the array, as long as anyone of them differs at the same index, it's not a duplicate.
+         */
+        public int kthSmallest(int[][] mat, int k) {
+            TreeSet<int[]> treeSet = new TreeSet<>(new Comparator<int[]>() {
+                @Override
+                public int compare(int[] o1, int[] o2) {
+                    if (o1[0] != o2[0]) {
+                        return o1[0] - o2[0];
+                    } else {
+                        for (int i = 1; i < o1.length; i++) {
+                            if (o1[i] != o2[i]) {
+                                return o1[i] - o2[i];
+                            }
+                        }
+                        return 0;
+                    }
+                }
+            });
+            int m = mat.length;
+            int n = mat[0].length;
+            int sum = 0;
+            int[] entry = new int[m + 1];
+            for (int i = 0; i < m; i++) {
+                sum += mat[i][0];
+            }
+            entry[0] = sum;
+            treeSet.add(entry);
+            int count = 0;
+            while (count < k) {
+                int[] curr = treeSet.pollFirst();
+                count++;
+                if (count == k) {
+                    return curr[0];
+                }
+                for (int i = 0; i < m; i++) {
+                    int[] next = Arrays.copyOf(curr, curr.length);
+                    if (curr[i + 1] + 1 < n) {
+                        next[0] -= mat[i][curr[i + 1]];
+                        next[0] += mat[i][curr[i + 1] + 1];
+                        next[i + 1]++;
+                        treeSet.add(next);
+                    }
+                }
+            }
+            return -1;
+        }
+    }
+}

src/test/java/com/fishercoder/_1439Test.java

@@ -0,0 +1,53 @@
+package com.fishercoder;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions._1439;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _1439Test {
+    private static _1439.Solution1 solution1;
+    private static int[][] mat;
+    private static int expected;
+    private static int k;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _1439.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        mat = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,3,11],[2,4,6]");
+        expected = 7;
+        k = 5;
+        assertEquals(expected, solution1.kthSmallest(mat, k));
+    }
+
+    @Test
+    public void test2() {
+        mat = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,3,11],[2,4,6]");
+        expected = 17;
+        k = 9;
+        assertEquals(expected, solution1.kthSmallest(mat, k));
+    }
+
+    @Test
+    public void test3() {
+        mat = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,10,10],[1,4,5],[2,3,6]");
+        expected = 9;
+        k = 7;
+        assertEquals(expected, solution1.kthSmallest(mat, k));
+    }
+
+    @Test
+    public void test4() {
+        mat = CommonUtils.convertLeetCodeIrregularLengths2DArrayInputIntoJavaArray("[1,1,10],[2,2,9]");
+        expected = 12;
+        k = 7;
+        assertEquals(expected, solution1.kthSmallest(mat, k));
+    }
+
+}