Implement ones-and-zeroes

name: ones-and-zeroes
url: https://leetcode.com/problems/ones-and-zeroes
difficulty: 2

time: 164 ms
time-rank: 86.66 %
time-complexity: O((m + n)N)

space: 102.5 MB
space-rank: 16.76 %
space-complexity: O(N*m*n)

Fixes #306

This is a 2-D 0-1 Knapsack problem

Signed-off-by: Christopher Friedt <[email protected]>

Author: cfriedt

ones-and-zeroes-test.cpp

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2021, Christopher Friedt
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#include <gtest/gtest.h>
+
+#include "ones-and-zeroes.cpp"
+
+using namespace std;
+
+TEST(OnesAndZeros, 10_0001_111001_1_0__5__3) {
+  vector<string> strs = {"10", "0001", "111001", "1", "0"};
+  int m = 5;
+  int n = 3;
+  EXPECT_EQ(4, Solution().findMaxForm(strs, m, n));
+}
+
+TEST(OnesAndZeros, 10_0_1__1__1) {
+  vector<string> strs = {"10", "0", "1"};
+  int m = 1;
+  int n = 1;
+  EXPECT_EQ(2, Solution().findMaxForm(strs, m, n));
+}
+
+TEST(OnesAndZeros, 10_0001_111001_1_0__4__3) {
+  vector<string> strs = {"10", "0001", "111001", "1", "0"};
+  int m = 4;
+  int n = 3;
+  EXPECT_EQ(3, Solution().findMaxForm(strs, m, n));
+}

ones-and-zeroes.cpp

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2021, Christopher Friedt
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+// clang-format off
+// name: ones-and-zeros
+// url: https://leetcode.com/problems/ones-and-zeroes
+// difficulty: 2
+// clang-format on
+
+#include <algorithm>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+public:
+  // this is a 2D 1-0 Knapsack problem where
+  // each item is either included or not included
+  // in the optimal subset and there are 2 different weights
+  int findMaxForm(vector<string> &strs, int m, int n) {
+    int N = strs.size();
+
+    // create the weight vectors
+    w0 = vector<int>(N);
+    w1 = vector<int>(N);
+    for (int i = 0; i < N; ++i) {
+      w0[i] = count(strs[i].begin(), strs[i].end(), '0');
+      w1[i] = strs[i].size() - w0[i];
+    }
+
+    // create the values vectors
+    // this is mainly for "muscle memory" - with the
+    // 0-1 Knapsack problem, elements can still have
+    // different weights.
+    val = vector<int>(N, 1);
+
+    // create a DP area
+    dp = vector<vector<vector<int>>>(
+        N + 1, vector<vector<int>>(m + 1, vector<int>(n + 1, -1)));
+
+    // after we have counted 0's and 1's in strs, it is actually not needed
+    // anymore
+    return KS(N, m, n);
+  }
+
+protected:
+  // "weight" in 0's of strs[i]
+  vector<int> w0;
+  // "weight" in 1's of strs[i]
+  vector<int> w1;
+  // values of each item
+  vector<int> val;
+
+  // memoization area for Dynamic Programming solution
+  vector<vector<vector<int>>> dp;
+
+  int KS(int i, int m, int n) {
+
+    // cout << "looking up dp[" << i << "][" << m << "][" << n << "]" << endl;
+    auto &result = dp[i][m][n];
+    if (result != -1) {
+      return result;
+    }
+
+    if (i == 0) {
+      result = 0;
+      return 0;
+    }
+
+    if (m == 0 && n == 0) {
+      result = 0;
+      return 0;
+    }
+
+    if (w0[i - 1] > m || w1[i - 1] > n) {
+      result = KS(i - 1, m, n);
+      return result;
+    }
+
+    auto t1 = KS(i - 1, m, n);
+    auto t2 = val[i - 1] + KS(i - 1, m - w0[i - 1], n - w1[i - 1]);
+
+    result = max(t1, t2);
+    return result;
+  }
+};