add 1296

fishercoder1534 · fishercoder1534 · commit 4d2cf646287e · 2019-12-22T07:04:52.000-08:00
diff --git a/src/main/java/com/fishercoder/solutions/_1296.java b/src/main/java/com/fishercoder/solutions/_1296.java
@@ -0,0 +1,80 @@
+package com.fishercoder.solutions;
+
+import java.util.TreeMap;
+
+/**
+ * 1296. Divide Array in Sets of K Consecutive Numbers
+ *
+ * Given an array of integers nums and a positive integer k,
+ * find whether it's possible to divide this array into sets of k consecutive numbers
+ * Return True if its possible otherwise return False.
+ *
+ * Example 1:
+ * Input: nums = [1,2,3,3,4,4,5,6], k = 4
+ * Output: true
+ * Explanation: Array can be divided into [1,2,3,4] and [3,4,5,6].
+ *
+ * Example 2:
+ * Input: nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
+ * Output: true
+ * Explanation: Array can be divided into [1,2,3] , [2,3,4] , [3,4,5] and [9,10,11].
+ *
+ * Example 3:
+ * Input: nums = [3,3,2,2,1,1], k = 3
+ * Output: true
+ *
+ * Example 4:
+ * Input: nums = [1,2,3,4], k = 3
+ * Output: false
+ * Explanation: Each array should be divided in subarrays of size 3.
+ *
+ * Constraints:
+ * 1 <= nums.length <= 10^5
+ * 1 <= nums[i] <= 10^9
+ * 1 <= k <= nums.length
+ * */
+public class _1296 {
+    public static class Solution1 {
+        public boolean isPossibleDivide(int[] nums, int k) {
+            if (nums.length % k != 0) {
+                return false;
+            }
+            TreeMap<Integer, Integer> treeMap = new TreeMap();
+            int min = nums[0];
+            for (int num : nums) {
+                treeMap.put(num, treeMap.getOrDefault(num, 0) + 1);
+                min = Math.min(min, num);
+            }
+            while (!treeMap.isEmpty()) {
+                if (!isConsecutiveK(treeMap, min, k)) {
+                    return false;
+                }
+                min = findNextMin(treeMap);
+                if (min == Integer.MIN_VALUE) {
+                    break;
+                }
+            }
+            return true;
+        }
+
+        private int findNextMin(TreeMap<Integer, Integer> treeMap) {
+            return treeMap.isEmpty() ? Integer.MIN_VALUE : treeMap.entrySet().iterator().next().getKey();
+        }
+
+        private boolean isConsecutiveK(TreeMap<Integer, Integer> treeMap, int min, int k) {
+            int count = treeMap.get(min);
+            treeMap.remove(min);
+            for (int i = 1; i < k; i++) {
+                int key = min + i;
+                if (!treeMap.containsKey(key) || treeMap.get(key) < count) {
+                    return false;
+                } else if (treeMap.get(key) > count) {
+                    treeMap.put(key, treeMap.get(key) - count);
+                } else {
+                    treeMap.remove(key);
+                }
+            }
+            return true;
+        }
+    }
+}
