Weekly Contest 133

Author: MaskRay

matrix-cells-in-distance-order.cc

@@ -0,0 +1,23 @@
+// Matrix Cells in Distance Order
+class Solution {
+public:
+  vector<vector<int>> allCellsDistOrder(int R, int C, int r0, int c0) {
+    unsigned r = R, c = C;
+    int x, y;
+    vector<vector<int>> a;
+    for (int i = 0; i < R+C-1; i++)
+      for (int j = 0; j <= i; j++) {
+        x = r0+j;
+        if (x < r) {
+          y = c0+i-j; if (y < c) a.push_back({x, y});
+          y = c0-i+j; if (j < i && y < c) a.push_back({x, y});
+        }
+        x = r0-j;
+        if (j && x < r) {
+          y = c0+i-j; if (y < c) a.push_back({x, y});
+          y = c0-i+j; if (j < i && y < c) a.push_back({x, y});
+        }
+      }
+    return a;
+  }
+};

maximum-sum-of-two-non-overlapping-subarrays.cc

@@ -0,0 +1,18 @@
+// Maximum Sum of Two Non-Overlapping Subarrays
+class Solution {
+public:
+  int maxSumTwoNoOverlap(vector<int>& A, int L, int M) {
+    int n = A.size(), r = 0;
+    vector<int> s(n+1);
+    for (int i = 0; i < n; i++)
+      s[i+1] = s[i]+A[i];
+    for (int _ = 2; _--; swap(L, M)) {
+      int m = 0;
+      for (int i = L+M; i <= n; i++) {
+        m = max(m, s[i-M]-s[i-M-L]);
+        r = max(r, s[i]-s[i-M]+m);
+      }
+    }
+    return r;
+  }
+};

stream-of-characters.cc

@@ -0,0 +1,54 @@
+// Stream of Characters
+class StreamChecker {
+  struct Node { int c[26], pi, end; } *pool, *allo, *x;
+  int sz;
+public:
+  StreamChecker(vector<string> &words) {
+    sz = 1;
+    pool = (Node*)malloc(sizeof(Node));
+    allo = pool;
+    memset(allo++, 0, sizeof(Node));
+    for (auto &w: words) {
+      Node *x = pool;
+      for (char c: w) {
+        if (!x->c[c-'a']) {
+          if (allo-pool >= sz) {
+            sz *= 2;
+            auto pool2 = (Node*)realloc(pool, sizeof(Node)*sz);
+            x = x-pool + pool2;
+            allo = allo-pool + pool2;
+            pool = pool2;
+          }
+          memset(allo, 0, sizeof(Node));
+          x->c[c-'a'] = allo++ - pool;
+        }
+        x = pool+x->c[c-'a'];
+      }
+      x->end = 1;
+    }
+    auto q = new int[allo-pool];
+    int qs = 0;
+    for (int i = 0; i < 26; i++)
+      if (pool->c[i])
+        q[qs++] = pool->c[i];
+    for (int i = 0; i < qs; i++) {
+      Node *x = pool+q[i];
+      x->end |= pool[x->pi].end;
+      for (int c = 0; c < 26; c++)
+        if (!x->c[c])
+          x->c[c] = pool[x->pi].c[c];
+        else {
+          pool[x->c[c]].pi = pool[x->pi].c[c];
+          q[qs++] = x->c[c];
+        }
+    }
+    x = pool;
+  }
+
+  ~StreamChecker() { free(pool); }
+
+  bool query(char letter) {
+    x = pool+x->c[letter-'a'];
+    return x->end;
+  }
+};

two-city-scheduling.cc

@@ -0,0 +1,14 @@
+// Two City Scheduling
+class Solution {
+public:
+  int twoCitySchedCost(vector<vector<int>>& costs) {
+    int n = costs.size()/2;
+    nth_element(costs.begin(), costs.begin()+n, costs.end(), [](auto &x, auto &y) {
+      return x[0]-x[1] < y[0]-y[1];
+    });
+    int r = 0;
+    for (int i = 0; i < n; i++)
+      r += costs[i][0]+costs[i+n][1];
+    return r;
+  }
+};