[N-0] add 698

Author: fishercoder1534

README.md

@@ -22,6 +22,7 @@ Your ideas/fixes/algorithms are more than welcome!
 
 |  #  |      Title     |   Solutions   | Time          | Space         | Difficulty  | Tag          | Notes
 |-----|----------------|---------------|---------------|---------------|-------------|--------------|-----
+|698|[Partition to K Equal Sum Subsets](https://leetcode.com/problems/partition-to-k-equal-sum-subsets/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_698.java) | O(n*(2^n)) | O(2^n) | Medium | Backtracking
 |697|[Degree of an Array](https://leetcode.com/problems/degree-of-an-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_697.java) | O(n) | O(n) | Easy | 
 |696|[Count Binary Substrings](https://leetcode.com/problems/count-binary-substrings/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_696.java) | O(n) | O(n) | Easy | 
 |695|[Max Area of Island](https://leetcode.com/problems/max-area-of-island/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_695.java) | O(m*n) | O(1) | Easy | DFS

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

@@ -0,0 +1,57 @@
+package com.fishercoder.solutions;
+
+/**
+ * 698. Partition to K Equal Sum Subsets
+ *
+ * Given an array of integers nums and a positive integer k,
+ * find whether it's possible to divide this array into k non-empty subsets whose sums are all equal.
+
+ Example 1:
+
+ Input: nums = [4, 3, 2, 3, 5, 2, 1], k = 4
+ Output: True
+ Explanation: It's possible to divide it into 4 subsets (5), (1, 4), (2,3), (2,3) with equal sums.
+
+ Note:
+ 1 <= k <= len(nums) <= 16.
+ 0 < nums[i] < 10000.
+ */
+public class _698 {
+
+    public static class Solution1 {
+        public boolean canPartitionKSubsets(int[] nums, int k) {
+            long sum = 0;
+            for (int num : nums) {
+                sum += num;
+            }
+            if (sum % k != 0) {
+                return false;
+            }
+            int equalSum = (int) (sum / k);
+            boolean[] visited = new boolean[nums.length];
+            return canPartition(nums, visited, 0, k, 0, 0, equalSum);
+        }
+
+        private boolean canPartition(int[] nums, boolean[] visited, int startIndex, int k, int currSum, int currNum, int target) {
+            if (k == 1) {
+                return true;
+            }
+            if (currSum == target && currNum > 0) {
+                /**Everytime when we get currSum == target, we'll start from index 0 and look up the numbers that are not used yet
+                 * and try to find another sum that could equal to target*/
+                return canPartition(nums, visited, 0, k - 1, 0, 0, target);
+            }
+            for (int i = startIndex; i < nums.length; i++) {
+                if (!visited[i]) {
+                    visited[i] = true;
+                    if (canPartition(nums, visited, i + 1, k, currSum + nums[i], currNum++, target)) {
+                        return true;
+                    }
+                    visited[i] = false;
+                }
+            }
+            return false;
+        }
+    }
+
+}

src/test/java/com/fishercoder/_698Test.java

@@ -0,0 +1,32 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._698;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _698Test {
+    private static _698.Solution1 solution1;
+    private static int[] nums;
+    private static int k;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _698.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{4, 3, 2, 3, 5, 2, 1};
+        k = 4;
+        assertEquals(true, solution1.canPartitionKSubsets(nums, k));
+    }
+
+    @Test
+    public void test2() {
+        nums = new int[]{-1,1,0,0};
+        k = 4;
+        assertEquals(false, solution1.canPartitionKSubsets(nums, k));
+    }
+}