✨ feat(contest): backup answers

Author: leevick

6345.cpp

@@ -0,0 +1,25 @@
+#include <iostream>
+
+using namespace std;
+
+class Solution {
+ public:
+  int kItemsWithMaximumSum(int numOnes, int numZeros, int numNegOnes, int k) {
+    int sum = 0;
+    if (k <= 0) return sum;
+    if (k <= numOnes) return k;
+    sum += numOnes;
+    k -= numOnes;
+    if (k <= numZeros) return sum;
+    k -= numZeros;
+    if (k <= numNegOnes) return sum - k;
+    return sum - numNegOnes;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  Solution s;
+  cout << s.kItemsWithMaximumSum(3, 2, 0, 2) << endl;
+  cout << s.kItemsWithMaximumSum(3, 2, 0, 4) << endl;
+  return 0;
+}

6355.cpp

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+ public:
+  bool primeSubOperation(vector<int>& nums) {
+    
+  }
+};
+
+int main(int argc, char const* argv[]) {
+  Solution s;
+  vector<int> v1 = {4, 9, 6, 10}, v2 = {6, 8, 11, 12}, v3 = {5, 8, 3};
+  cout << s.primeSubOperation(v1) << endl;
+  cout << s.primeSubOperation(v2) << endl;
+  cout << s.primeSubOperation(v3) << endl;
+  return 0;
+}

6357.cpp

@@ -0,0 +1,33 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+ public:
+  vector<long long> minOperations(vector<int>& nums, vector<int>& queries) {
+    int n = nums.size(), m = queries.size();
+    vector<long long> ret(m, 0);
+    for (auto i = 0; i < n; ++i) {
+      for (auto j = 0; j < m; ++j) {
+        ret[j] += nums[i] - queries[j] > 0 ? nums[i] - queries[j]
+                                           : queries[j] - nums[i];
+      }
+    }
+    return ret;
+  }
+};
+
+int main(int argc, char const* argv[]) {
+  Solution s;
+  vector<int> n1 = {3, 1, 6, 8}, n2 = {2, 9, 6, 3}, n3 = {};
+  vector<int> q1 = {1, 5}, q2 = {10}, q3 = {};
+
+  auto ret = s.minOperations(n2, q2);
+  for (auto i : ret) {
+    cout << i << " ";
+  }
+  cout << endl;
+
+  return 0;
+}

6362.cpp

@@ -0,0 +1,62 @@
+#include <string>
+#include <vector>
+#include <iostream>
+#include <algorithm>
+
+using namespace std;
+
+class Solution {
+ public:
+  int findTheLongestBalancedSubstring(string s) {
+    int n = s.size();
+    int mx = 0, zsum = 0, osum = 0;
+    int state = 0;
+
+    for (int i = 0; i < n; ++i) {
+      switch (state) {
+        case 0: {
+          if (s[i] == '0') {
+            state = 1;
+            zsum++;
+          }
+        } break;
+        case 1: {
+          if (s[i] == '0') {
+            zsum++;
+          } else {
+            state = 2;
+            osum++;
+            if (osum == zsum) {
+              mx = max(mx, 2 * osum);
+            }
+          }
+        } break;
+        case 2: {
+          if (s[i] == '0') {
+            zsum = 1;
+            osum = 0;
+            state = 1;
+          } else {
+            osum++;
+            if (osum == zsum) {
+              mx = max(mx, 2 * osum);
+            }
+          }
+        } break;
+      }
+    }
+
+    return mx;
+  }
+};
+
+int main(int argc, char const *argv[]) {
+  Solution s;
+
+  cout << s.findTheLongestBalancedSubstring("01000111") << endl;
+  cout << s.findTheLongestBalancedSubstring("00111") << endl;
+  cout << s.findTheLongestBalancedSubstring("111") << endl;
+  cout << s.findTheLongestBalancedSubstring("01") << endl;
+
+  return 0;
+}

6363.cpp

@@ -0,0 +1,61 @@
+#include <string>
+#include <vector>
+#include <iostream>
+#include <unordered_map>
+#include <algorithm>
+#include <unordered_set>
+
+using namespace std;
+
+class Solution {
+ public:
+  vector<vector<int>> findMatrix(vector<int>& nums) {
+    vector<vector<int>> ret;
+    unordered_map<int, int> hash;
+    unordered_set<int> collect;
+    for (auto nu : nums) {
+      hash[nu] = hash[nu] + 1;
+      collect.insert(nu);
+    }
+
+    while (!collect.empty()) {
+      vector<int> row;
+      for (auto i = hash.begin(); i != hash.end(); ++i) {
+        if (i->second == 0) {
+          continue;
+        } else {
+          row.push_back(i->first);
+          i->second = i->second - 1;
+          if (i->second == 0) {
+            collect.erase(i->first);
+          }
+        }
+      }
+      ret.push_back(row);
+    }
+
+    return ret;
+  }
+};
+
+int main(int argc, char const* argv[]) {
+  Solution s;
+  vector<int> v1 = {1, 3, 4, 1, 2, 3, 1};
+  vector<int> v2 = {1, 2, 3, 4};
+  auto res1 = s.findMatrix(v1);
+  for (auto r : res1) {
+    for (auto c : r) {
+      cout << c << " ";
+    }
+    cout << endl;
+  }
+
+  auto res2 = s.findMatrix(v2);
+  for (auto r : res2) {
+    for (auto c : r) {
+      cout << c << " ";
+    }
+    cout << endl;
+  }
+  return 0;
+}

6364.cpp

@@ -0,0 +1,56 @@
+#include <string>
+#include <vector>
+#include <iostream>
+#include <unordered_map>
+#include <algorithm>
+#include <unordered_set>
+
+using namespace std;
+
+class Solution {
+ public:
+  int miceAndCheese(vector<int>& reward1, vector<int>& reward2, int k) {
+    struct cheese {
+      int value;
+      int mouse;
+      int m1;
+      int m2;
+      bool operator<(const cheese& c) { return this->value > c.value; }
+    };
+
+    int ret = 0, n = reward1.size();
+    vector<cheese> c;
+    vector<int> v(n, 0);
+    for (int i = 0; i < n; ++i) {
+      cheese ch;
+      ch.value = reward1[i] - reward2[i];
+      ch.m1 = reward1[i];
+      ch.m2 = reward2[i];
+      c.push_back(ch);
+    }
+
+    sort(c.begin(), c.end());
+
+    for (int i = 0; i < k; ++i) {
+      ret += c[i].m1;
+    }
+
+    for (int i = k; i < n; ++i) {
+      ret += c[i].m2;
+    }
+    return ret;
+  }
+};
+
+int main(int argc, char const* argv[]) {
+  Solution s;
+  vector<int> rw11 = {1, 1, 3, 4}, rw12 = {4, 4, 1, 1}, rw21 = {1, 1},
+              rw22 = {1, 1}, rw31 = {1, 4, 4, 6, 4}, rw32 = {6, 5, 3, 6, 1};
+  int k1 = 2, k2 = 2, k3 = 1;
+
+  cout << s.miceAndCheese(rw11, rw12, k1) << endl;
+  cout << s.miceAndCheese(rw21, rw22, k2) << endl;
+  cout << s.miceAndCheese(rw31, rw32, k3) << endl;
+
+  return 0;
+}