Weekly Contest 86

Author: MaskRay

find-and-replace-in-string.cc

@@ -0,0 +1,29 @@
+// Find And Replace in String
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  string findReplaceString(string S, vector<int>& indexes, vector<string>& sources, vector<string>& targets) {
+    int m = indexes.size();
+    vector<int> p(m);
+    iota(ALL(p), 0);
+    sort(ALL(p), [&](int a, int b) {return indexes[a] < indexes[b];});
+    string r;
+    int n = S.size();
+    for (int j = 0, i = 0; i < n; ) {
+      while (j < indexes.size() && indexes[p[j]] < i) j++;
+      while (j < indexes.size() && indexes[p[j]] == i) {
+        if (i + sources[p[j]].size() <= n &&
+          S.compare(i, sources[p[j]].size(), sources[p[j]]) == 0) {
+          i += sources[p[j]].size();
+          r += targets[p[j]];
+          goto next;
+        }
+        j++;
+      }
+      r += S[i++];
+    next:;
+    }
+    return r;
+  }
+};

flipping-an-image.cc

@@ -0,0 +1,17 @@
+// Flipping an Image
+#define ALL(x) (x).begin(), (x).end()
+#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>> flipAndInvertImage(vector<vector<int>> &A) {
+    int m = A.size(), n = A[0].size();
+    REP(i, m) {
+      reverse(ALL(A[i]));
+      REP(j, n)
+        A[i][j] ^= 1;
+    }
+    return A;
+  }
+};

guess-the-word.cc

@@ -0,0 +1,32 @@
+// Guess the Word
+#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 {
+  int same(string& a, string& b) {
+    int c = 0;
+    REP(i, 6)
+      c += a[i] == b[i];
+    return c;
+  }
+public:
+  void findSecretWord(vector<string>& ws, Master& master) {
+    while (ws.size()) {
+      int opt = ws.size()+1, opt_i = -1;
+      REP(i, ws.size()) {
+        int cnt[7] = {};
+        REP(j, ws.size())
+          cnt[same(ws[i], ws[j])]++;
+        int t = *max_element(cnt, cnt+7);
+        if (t < opt)
+          opt = t, opt_i = i;
+      }
+      string g = ws[opt_i];
+      ws.erase(ws.begin()+opt_i);
+      int t = master.guess(g);
+      ws.erase(remove_if(ws.begin(), ws.end(),
+                         [&](string& s) { return same(g, s) != t; }),
+               ws.end());
+    }
+  }
+};

image-overlap.cc

@@ -0,0 +1,22 @@
+// Image Overlap
+#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:
+  int largestOverlap(vector<vector<int>>& A, vector<vector<int>>& B) {
+    int n = A.size(), r = 0;
+    FOR(dx, -n+1, n)
+      FOR(dy, -n+1, n) {
+        int o = 0;
+        REP(i, n)
+          REP(j, n) {
+            int ii = i+dx, jj = j+dy;
+            if (B[i][j] && unsigned(ii) < n && unsigned(jj) < n && A[ii][jj])
+              o++;
+          }
+        r = max(r, o);
+      }
+    return r;
+  }
+};

keys-and-rooms.cc

@@ -0,0 +1,21 @@
+// Keys and Rooms
+class Solution {
+public:
+  bool canVisitAllRooms(vector<vector<int>>& rs) {
+    int n = rs.size();
+    vector<int> st{0};
+    vector<char> c(n);
+    c[0] = 1;
+    while (st.size()) {
+      n--;
+      int x = st.back();
+      st.pop_back();
+      for (int y: rs[x])
+        if (!c[y]) {
+          c[y] = 1;
+          st.push_back(y);
+        }
+    }
+    return !n;
+  }
+};

magic-squares-in-grid.cc

@@ -0,0 +1,28 @@
+// Magic Squares In 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:
+  int numMagicSquaresInside(vector<vector<int>>& a) {
+    int n = a.size(), s = 0;
+    REP(i, n-2)
+      REP(j, n-2) {
+        char b[10] = {};
+        REP(ii, 3)
+          REP(jj, 3) {
+            if (a[i+ii][j+jj] > 9) goto nxt;
+            b[a[i+ii][j+jj]] = 1;
+          }
+        FOR(i, 1, 10) if (!b[i]) goto nxt;
+        REP(k, 3) {
+          if (a[i+k][j]+a[i+k][j+1]+a[i+k][j+2] != 15) goto nxt;
+          if (a[i][j+k]+a[i+1][j+k]+a[i+2][j+k] != 15) goto nxt;
+        }
+        if (a[i][j]+a[i+1][j+1]+a[i+2][j+2] != 15) goto nxt;
+        s++;
+        nxt:;
+      }
+    return s;
+  }
+};

split-array-into-fibonacci-sequence.cc

@@ -0,0 +1,44 @@
+// Split Array into Fibonacci Sequence
+#define ALL(x) (x).begin(), (x).end()
+#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
+
+class Solution {
+public:
+  vector<int> splitIntoFibonacci(string S) {
+    int n = S.size();
+    long ta = 1, tb = 1;
+    long oa = 0, ob, oc, a, b, c;
+    vector<int> ret;
+    ROF(i, 0, n) {
+      oa += ta*(S[i]-'0');
+      ta *= 10;
+      if (oa > INT_MAX) break;
+      ob = 0;
+      tb = 1;
+      ROF(j, 0, i) {
+        ob += tb*(S[j]-'0');
+        tb *= 10;
+        if (ob > oa) break;
+        int k = j-1;
+        ret.clear();
+        ret.push_back(a = oa);
+        ret.push_back(b = ob);
+        while (k >= 0) {
+          c = a-b;
+          oc = c;
+          do if (S[k]-'0' != oc % 10) goto nxt;
+          while (k--, oc /= 10);
+          a = b;
+          b = c;
+          ret.push_back(c);
+        }
+      nxt:
+        if (k < 0 && ret.size() >= 3) {
+          reverse(ALL(ret));
+          return ret;
+        }
+      }
+    }
+    return {};
+  }
+};

sum-of-distances-in-tree.cc

@@ -0,0 +1,35 @@
+// Sum of Distances in Tree
+class Solution {
+  vector<vector<int>> es;
+  vector<int> ss, ans;
+  int n;
+  int f(int u, int p, int d) {
+    int ds = d;
+    ss[u] = 1;
+    for (int v: es[u])
+      if (v != p) {
+        ds += f(v, u, d+1);
+        ss[u] += ss[v];
+      }
+    return ds;
+  }
+  void g(int u, int p, int tot) {
+    ans[u] = tot;
+    for (int v: es[u])
+      if (v != p)
+        g(v, u, tot-ss[v]*2+n);
+  }
+public:
+  vector<int> sumOfDistancesInTree(int N, vector<vector<int>>& edges) {
+    n = N;
+    es.resize(N);
+    ss.resize(N);
+    ans.resize(N);
+    for (auto& e:edges) {
+      es[e[0]].push_back(e[1]);
+      es[e[1]].push_back(e[0]);
+    }
+    g(0, -1, f(0, -1, 0));
+    return ans;
+  }
+};