Weekly Contest 163

Author: MaskRay

find-elements-in-a-contaminated-binary-tree.cc

@@ -0,0 +1,18 @@
+// Find Elements in a Contaminated Binary Tree
+class FindElements {
+  unordered_set<int> s;
+  void f(TreeNode *x, int v) {
+    if (!x) return;
+    x->val = v;
+    s.insert(v);
+    f(x->left, 2*v+1);
+    f(x->right, 2*v+2);
+  }
+public:
+  FindElements(TreeNode* root) {
+    f(root, 0);
+  }
+  bool find(int target) {
+    return s.count(target);
+  }
+};

greatest-sum-divisible-by-three.cc

@@ -0,0 +1,23 @@
+// Greatest Sum Divisible by Three
+class Solution {
+public:
+  int maxSumDivThree(vector<int>& nums) {
+    int tot = 0, ans = 0, a[2] = {10001, 10001}, b[2] = {10001, 10001};
+    for (int x: nums) {
+      int k = x%3;
+      if (k--) {
+        b[k] = min(b[k], x);
+        if (b[k] < a[k]) swap(a[k], b[k]);
+      }
+      tot += x;
+    }
+    int k = tot%3;
+    if (!k--)
+      return tot;
+    if (a[k] < 10001)
+      ans = tot-a[k];
+    if (b[k^1] < 10001)
+      ans = max(ans, tot-a[k^1]-b[k^1]);
+    return ans;
+  }
+};

minimum-moves-to-move-a-box-to-their-target-location.cc

@@ -0,0 +1,54 @@
+// Minimum Moves to Move a Box to Their Target Location
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+int vis[20][20][20];
+
+class Solution {
+public:
+  int minPushBox(vector<vector<char>>& grid) {
+    using pii = pair<int, int>;
+    using state = pair<pii, pii>;
+    int n = grid.size(), m = grid[0].size();
+    pii src, box, tar;
+    const int dirs[][2] = {{0,-1},{-1,0},{0,1},{1,0}};
+    REP(i, n) REP(j, m)
+      switch (grid[i][j]) {
+      case 'S': src = {i, j}; break;
+      case 'B': box = {i, j}; break;
+      case 'T': tar = {i, j}; break;
+      }
+    memset(vis, 0, sizeof vis);
+    deque<state> q;
+    q.push_back({src, box});
+    vis[src.first][src.second][box.first] = 1 << box.second;
+    int d = 0, e = 1;
+    while (q.size()) {
+      state c = q.front();
+      q.pop_front();
+      if (e) e--;
+      else e = q.size(), d++;
+      for (auto dir: dirs) {
+        unsigned x = c.first.first+dir[0], y = c.first.second+dir[1];
+        if (x >= n || y >= m || grid[x][y] == '#') continue;
+        state s;
+        int cost = 0;
+        if (pii(x, y) == c.second) {
+          unsigned xx = x+dir[0], yy = y+dir[1];
+          if (xx >= n || yy >= m || grid[xx][yy] == '#') continue;
+          if (pii(xx, yy) == tar) return d+1;
+          s = {{x, y}, {xx, yy}};
+          cost = 1;
+        } else
+          s = {{x, y}, c.second};
+        int &v = vis[x][y][s.second.first];
+        if (!(v & 1 << s.second.second)) {
+          v |= 1 << s.second.second;
+          if (cost) q.push_back(s);
+          else e++, q.push_front(s);
+        }
+      }
+    }
+    return -1;
+  }
+};

shift-2d-grid.cc

@@ -0,0 +1,18 @@
+// Shift 2D Grid
+#define FOR(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (a); i < (b); i++)
+#define REP(i, n) FOR(i, 0, n)
+
+class Solution {
+public:
+  vector<vector<int>> shiftGrid(vector<vector<int>>& grid, int k) {
+    int n = grid.size(), m = grid[0].size(), g = 0;
+    vector<int> a(n*m);
+    REP(i, n) REP(j, m)
+      a[g++] = grid[i][j];
+    rotate(a.begin(), a.end()-k%(n*m), a.end());
+    g = 0;
+    REP(i, n) REP(j, m)
+      grid[i][j] = a[g++];
+    return grid;
+  }
+};