Weekly Contest 127

Author: MaskRay

clumsy-factorial.cc

@@ -0,0 +1,11 @@
+// Clumsy Factorial
+class Solution {
+public:
+  int clumsy(int N) {
+    if (N <= 2) return N;
+    int s = N*(N-1)/(N-2);
+    for (N -= 3; N > 0; N -= 4)
+      s += N - max(N-1, 0) * max(N-2, 1) / max(N-3, 1);
+    return s;
+  }
+};

construct-binary-search-tree-from-preorder-traversal.cc

@@ -0,0 +1,23 @@
+// Construct Binary Search Tree from Preorder Traversal
+class Solution {
+public:
+  TreeNode* bstFromPreorder(vector<int>& p) {
+    vector<TreeNode *> s;
+    TreeNode *r = nullptr, *y;
+    for (auto v: p) {
+      y = 0;
+      while (s.size() && s.back()->val < v) {
+        y = s.back();
+        s.pop_back();
+      }
+      s.push_back(new TreeNode(v));
+      if (!r)
+        r = s.back();
+      if (y)
+        y->right = s.back();
+      else if (s.size() > 1)
+        s[s.size()-2]->left = s.back();
+    }
+    return r;
+  }
+};

maximize-sum-of-array-after-k-negations.cc

@@ -0,0 +1,19 @@
+// Maximize Sum Of Array After K Negations
+class Solution {
+public:
+  int largestSumAfterKNegations(vector<int>& A, int K) {
+    auto it = partition(A.begin(), A.end(), bind(less<>(), placeholders::_1, 0));
+    if (K < it-A.begin()) {
+      nth_element(A.begin(), A.begin()+K, it);
+      transform(A.begin(), A.begin()+K, A.begin(), negate<>());
+    } else {
+      transform(A.begin(), it, A.begin(), negate<>());
+      if (K-(it-A.begin()) & 1) {
+        it = min_element(A.begin(), it);
+        auto it1 = min_element(it, A.end());
+        (it == A.begin() || it1 != A.end() && *it1 < *it ? *it1 : *it) *= -1;
+      }
+    }
+    return accumulate(A.begin(), A.end(), 0);
+  }
+};

minimum-domino-rotations-for-equal-row.cc

@@ -0,0 +1,21 @@
+// Minimum Domino Rotations For Equal Row
+class Solution {
+public:
+  int minDominoRotations(vector<int>& A, vector<int>& B) {
+    int r = A.size()+1;
+    for (int d = 1; d <= 6; d++) {
+      int a = 0, b = 0;
+      for (int i = 0; i < A.size(); i++) {
+        if (d == A[i]) {
+          if (d != B[i])
+            b++;
+        } else if (d == B[i])
+          a++;
+        else
+          a = b = A.size()+1;
+      }
+      r = min(r, min(a, b));
+    }
+    return r > n ? -1 : r;
+  }
+};