OnesAndZeroes474

Author: fluency03

README.md

@@ -44,11 +44,11 @@
 | [Graph](https://github.com/fluency03/leetcode-java/blob/master/src/graph) |
 
 
-# Total: 380
+# Total: 381
 
 |   Easy  |  Medium | Hard | - |
 |:-------:|:-------:|:----:|:-:|
-|   102   |   208   |  66  | 4 |
+|   102   |   209   |  66  | 4 |
 
 
 | Question | Solution | Difficulty |
@@ -333,6 +333,7 @@
 | [451. Sort Characters By Frequency](https://leetcode.com/problems/sort-characters-by-frequency/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/SortCharactersByFrequency451.java) | Medium |
 | [462. Minimum Moves to Equal Array Elements II](https://leetcode.com/problems/minimum-moves-to-equal-array-elements-ii/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/MinimumMovesToEqualArrayElementsII462.java) | Medium |
 | [463. Island Perimeter](https://leetcode.com/problems/island-perimeter/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/IslandPerimeter463.java) | Easy |
+| [474. Ones and Zeroes](https://leetcode.com/problems/ones-and-zeroes/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/OnesAndZeroes474.java) | Medium |
 | [477. Total Hamming Distance](https://leetcode.com/problems/total-hamming-distance) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/TotalHammingDistance477.java) | Medium |
 | [480. Sliding Window Median](https://leetcode.com/problems/sliding-window-median/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/SlidingWindowMedian480.java) | Hard |
 | [481. Magical String](https://leetcode.com/problems/magical-string/) | [Solution](https://github.com/fluency03/leetcode-java/blob/master/src/MagicalString481.java) | Medium |

src/OnesAndZeroes474.java

@@ -0,0 +1,72 @@
+/**
+ * In the computer world, use restricted resource you have to generate maximum
+ * benefit is what we always want to pursue.
+ * 
+ * For now, suppose you are a dominator of m 0s and n 1s respectively. On the
+ * other hand, there is an array with strings consisting of only 0s and 1s.
+ * 
+ * Now your task is to find the maximum number of strings that you can form
+ * with given m 0s and n 1s. Each 0 and 1 can be used at most once.
+ * 
+ * Note:
+ * The given numbers of 0s and 1s will both not exceed 100
+ * The size of given string array won't exceed 600.
+ * 
+ * Example 1:
+ * Input: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
+ * Output: 4
+ * Explanation: This are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are “10,”0001”,”1”,”0”
+ * 
+ * Example 2:
+ * Input: Array = {"10", "0", "1"}, m = 1, n = 1
+ * Output: 2
+ * Explanation: You could form "10", but then you'd have nothing left. Better form "0" and "1".
+ */
+
+public class OnesAndZeroes474 {
+    /**
+     * https://leetcode.com/problems/ones-and-zeroes/solution/
+     */
+    public int findMaxForm(String[] strs, int m, int n) {
+        int[][][] memo = new int[strs.length][m + 1][n + 1];
+        return calculate(strs, 0, m, n, memo);
+    }
+    public int calculate(String[] strs, int i, int zeroes, int ones, int[][][] memo) {
+        if (i == strs.length)
+            return 0;
+        if (memo[i][zeroes][ones] != 0)
+            return memo[i][zeroes][ones];
+        int[] count = countzeroesones(strs[i]);
+        int taken = -1;
+        if (zeroes - count[0] >= 0 && ones - count[1] >= 0)
+            taken = calculate(strs, i + 1, zeroes - count[0], ones - count[1], memo) + 1;
+        int not_taken = calculate(strs, i + 1, zeroes, ones, memo);
+        memo[i][zeroes][ones] = Math.max(taken, not_taken);
+        return memo[i][zeroes][ones];
+    }
+    public int[] countzeroesones(String s) {
+        int[] c = new int[2];
+        for (int i = 0; i < s.length(); i++) {
+            c[s.charAt(i)-'0']++;
+        }
+        return c;
+    }
+
+
+    /**
+     * https://leetcode.com/problems/ones-and-zeroes/solution/
+     */
+    public int findMaxForm2(String[] strs, int m, int n) {
+        int[][] dp = new int[m + 1][n + 1];
+        for (String s: strs) {
+            int[] count = countzeroesones(s);
+            for (int zeroes = m; zeroes >= count[0]; zeroes--)
+                for (int ones = n; ones >= count[1]; ones--)
+                    dp[zeroes][ones] = Math.max(1 + dp[zeroes - count[0]][ones - count[1]], dp[zeroes][ones]);
+        }
+        return dp[m][n];
+    }
+
+}
+
+