Weekly Contest 136

Author: MaskRay

escape-a-large-maze.cc

@@ -1,21 +1,43 @@
 // Escape a Large Maze
+#define ALL(x) (x).begin(), (x).end()
+
 class Solution {
 public:
   bool isEscapePossible(vector<vector<int>>& bs, vector<int>& src, vector<int>& dst) {
-    const long N = 1000001;
-    unordered_set<long> v;
-    for (auto &b: bs)
-      v.insert(b[0]*N+b[1]);
-    vector<pair<int,int>> q{{src[0], src[1]}};
-    v.insert(src[0]*N+src[1]);
+    vector<int> xs, ys;
+    for (auto &b: bs) {
+      xs.push_back(b[0]);
+      if (b[0]+1 < 1000000) xs.push_back(b[0]+1);
+      ys.push_back(b[1]);
+      if (b[1]+1 < 1000000) ys.push_back(b[1]+1);
+    }
+    xs.push_back(0); xs.push_back(999999); xs.push_back(dst[0]);
+    sort(ALL(xs)); xs.erase(unique(ALL(xs)), xs.end());
+    ys.push_back(0); ys.push_back(999999); ys.push_back(dst[1]);
+    sort(ALL(ys)); ys.erase(unique(ALL(ys)), ys.end());
+
+    int n = xs.size(), m = ys.size(), x, y;
+    vector<vector<char>> v(n, vector<char>(m));
+    for (auto &b: bs) {
+      x = lower_bound(ALL(xs), b[0])-xs.begin();
+      y = lower_bound(ALL(ys), b[1])-ys.begin();
+      v[x][y] = 1;
+    }
+
+    int sx = lower_bound(ALL(xs), src[0])-xs.begin();
+    int sy = lower_bound(ALL(ys), src[1])-ys.begin();
+    int tx = lower_bound(ALL(xs), dst[0])-xs.begin();
+    int ty = lower_bound(ALL(ys), dst[1])-ys.begin();
+    vector<pair<int,int>> q;
+    q.emplace_back(sx, sy);
+    v[sx][sy] = 1;
     for (int i=0; i<q.size(); i++) {
-      int x, y;
       tie(x, y) = q[i];
-      if (i == 200*200 || x == dst[0] && y == dst[1]) return true;
-      if (x && v.insert((x-1)*N+y).second) q.emplace_back(x-1, y);
-      if (x+1<N-1 && v.insert((x+1)*N+y).second) q.emplace_back(x+1, y);
-      if (y && v.insert(x*N+y-1).second) q.emplace_back(x, y-1);
-      if (y+1<N-1 && v.insert(x*N+y+1).second) q.emplace_back(x, y+1);
+      if (x == tx && y == ty) return true;
+      if (x && !v[x-1][y]++) q.emplace_back(x-1, y);
+      if (x+1<n && !v[x+1][y]++) q.emplace_back(x+1, y);
+      if (y && !v[x][y-1]++) q.emplace_back(x, y-1);
+      if (y+1<m && !v[x][y+1]++) q.emplace_back(x, y+1);
     }
     return false;
   }

flower-planting-with-no-adjacent.cc

@@ -0,0 +1,33 @@
+// Flower Planting With No Adjacent
+class Solution {
+public:
+  vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
+    vector<int> g[N], c(N);
+    for (auto &p: paths) {
+      g[p[0]-1].push_back(p[1]-1);
+      g[p[1]-1].push_back(p[0]-1);
+    }
+    for (int i = 0; i < N; i++)
+      if (!c[i]) {
+        vector<int> q;
+        int u = i;
+        for(;;) {
+          int t[6] = {};
+          for (int v: g[u])
+            if (c[v])
+              t[c[v]] = 1;
+            else
+              c[v] = 5, q.push_back(v);
+          for (int k = 1; ; k++)
+            if (!t[k]) {
+              c[u] = k;
+              break;
+            }
+          if (q.empty()) break;
+          u = q.back();
+          q.pop_back();
+        }
+      }
+    return c;
+  }
+};

longest-duplicate-substring.cc

@@ -0,0 +1,55 @@
+// Longest Duplicate Substring
+#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)
+#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
+
+class Solution {
+public:
+  string longestDupSubstring(string S) {
+    const char *a = S.c_str();
+    int n = S.size(), m = 256;
+    int *sa = new int[n], *r = new int[n], *h = new int[max(n, 256)], *x = new int[n];
+    fill_n(h, m, 0);
+    copy_n(a, n, r);
+    REP(i, n) h[r[i]]++;
+    FOR(i, 1, m) h[i] += h[i-1];
+    ROF(i, 0, n) sa[--h[r[i]]] = i;
+    int k = 1;
+    for (; ; k <<= 1) {
+      iota(x, x+k, n-k);
+      int j = k;
+      REP(i, n) if (sa[i] >= k) x[j++] = sa[i]-k;
+      fill_n(h, m, 0);
+      REP(i, n) h[r[x[i]]]++;
+      FOR(i, 1, m) h[i] += h[i-1];
+      ROF(i, 0, n) sa[--h[r[x[i]]]] = x[i];
+      fill_n(h, m, 0);
+      m = 1;
+      h[sa[0]] = 0;
+      FOR(i, 1, n) {
+        if (r[sa[i]] != r[sa[i-1]] || max(sa[i], sa[i-1]) >= n-k || r[sa[i]+k] != r[sa[i-1]+k]) m++;
+        h[sa[i]] = m-1;
+      }
+      copy_n(h, n, r);
+      if (m == n) break;
+    }
+    k = 0;
+    h[0] = 0;
+    REP(i, n)
+      if (r[i]) {
+        for (int j = sa[r[i]-1]; max(i, j)+k < n && a[i+k] == a[j+k]; k++);
+        h[r[i]] = k;
+        k && k--;
+      }
+    int ans = -1, ansx;
+    REP(i, n)
+      if (h[i] > ans)
+        ans = h[ansx = i];
+    string ret = S.substr(sa[ansx], ans);
+    delete[] sa;
+    delete[] r;
+    delete[] h;
+    delete[] x;
+    return ret;
+  }
+};

partition-array-for-maximum-sum.cc

@@ -0,0 +1,19 @@
+// Partition Array for Maximum Sum
+#define REP1(i, n) for (remove_cv<remove_reference<decltype(n)>::type>::type i = 1; i <= (n); i++)
+#define ROF(i, a, b) for (remove_cv<remove_reference<decltype(b)>::type>::type i = (b); --i >= (a); )
+
+class Solution {
+public:
+  int maxSumAfterPartitioning(vector<int>& A, int K) {
+    int n = A.size();
+    vector<int> s(n+1);
+    REP1(i, n) {
+      int mx = 0;
+      ROF(j, max(0, i-K), i) {
+        mx = max(mx, A[j]);
+        s[i] = max(s[i], s[j]+(i-j)*mx);
+      }
+    }
+    return s[n];
+  }
+};

robot-bounded-in-circle.cc

@@ -0,0 +1,13 @@
+// Robot Bounded In Circle
+class Solution {
+public:
+  bool isRobotBounded(string instructions) {
+    int x[2]={}, d=3;
+    for (int i = 4; i--; )
+      for (char c: instructions)
+        if (c == 'L') d--;
+        else if (c == 'R') d++;
+        else x[d&1] += (d&2)-1;
+    return !(x[0]|x[1]);
+  }
+};