misc

Author: MaskRay

contest/2021-spring/守卫城堡.cc

@@ -0,0 +1,78 @@
+#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)
+
+namespace {
+const int N = 10000, V = 4*N+3;
+struct Edge {int v, c, next; } e[N*12*2];
+// src is sink-1
+int head[V], allo, sink, h[V+2], nh[V+3];
+
+void insert(int u, int v, int c) {
+  e[allo] = Edge{v, c, head[u]}; head[u] = allo++;
+  e[allo] = Edge{u, 0, head[v]}; head[v] = allo++;
+}
+
+int augment(int u, int d, int sink) {
+  if (u == sink) return d;
+  int old = d, minh = sink;
+  for (int i = head[u]; ~i; i = e[i].next)
+    if (e[i].c > 0) {
+      int v = e[i].v;
+      if (h[v]+1 == h[u]) {
+        int dd = augment(v, min(d, e[i].c), sink);
+        e[i].c -= dd;
+        e[i^1].c += dd;
+        if (!(d -= dd) || h[sink-1] > sink) break;
+      }
+      minh = min(minh, h[v]);
+    }
+  if (d == old) {
+    if (!--nh[h[u]]) h[sink-1] = sink+1;
+    nh[h[u] = minh+1]++;
+  }
+  return old-d;
+}
+}
+
+class Solution {
+public:
+  int guardCastle(vector<string>& grid) {
+    int n = grid[0].size(), p = 4*n, src = p+1;
+    sink = src+1;
+    fill_n(head, sink+1, -1);
+    allo = 0;
+
+    REP(i, 2) REP(j, n) {
+      int v = (2*j+i)*2;
+      if (grid[i][j] == '.')
+        insert(v, v+1, 1);
+      else if (grid[i][j] != '#')
+        insert(v, v+1, INT_MAX);
+
+      if (grid[i][j] == 'C')
+        insert(src, v, INT_MAX);
+      else if (grid[i][j] == 'S')
+        insert(v, sink, INT_MAX);
+      else if (grid[i][j] == 'P') {
+        insert(p, v, INT_MAX);
+        insert(v+1, p, INT_MAX);
+      }
+
+      REP(d, 4) {
+        const int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
+        unsigned i1 = i+dx[d], j1 = j+dy[d];
+        if (i1 < 2 && j1 < n)
+          insert(v+1, (2*j1+i1)*2, INT_MAX);
+      }
+    }
+
+    int flow = 0;
+    fill_n(h, sink+1, 0);
+    fill_n(nh, sink+2, 0);
+    while (h[src] <= sink) {
+      flow += augment(src, INT_MAX, sink);
+      if (flow >= 2*n) return -1;
+    }
+    return flow;
+  }
+};

longest-increasing-path-in-a-matrix.cc

@@ -1,32 +1,27 @@
 // Longest Increasing Path in a Matrix
-#define REP(i, n) for (int i = 0; i < (n); i++)
+#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 m, n;
   vector<vector<int>> a, dp;
   int dfs(int i, int j) {
     if (dp[i][j]) return dp[i][j];
     int s = 0;
-    if (i && a[i][j] < a[i-1][j]) s = max(s, dfs(i-1, j));
-    if (i+1 < m && a[i][j] < a[i+1][j]) s = max(s, dfs(i+1, j));
-    if (j && a[i][j] < a[i][j-1]) s = max(s, dfs(i, j-1));
-    if (j+1 < n && a[i][j] < a[i][j+1]) s = max(s, dfs(i, j+1));
+    REP(d, 4) {
+      unsigned i1 = i+((int []){-1,0,1,0})[d], j1 = j+((int []){0,1,0,-1})[d];
+      if (i1 < a.size() && j1 < a[0].size() && a[i][j] < a[i1][j1])
+        s = max(s, dfs(i1, j1));
+    }
     return dp[i][j] = s+1;
   }
 public:
   int longestIncreasingPath(vector<vector<int>>& a) {
-    m = a.size();
-    if (! m) return 0;
-    n = a[0].size();
-    dp.resize(m);
-    REP(i, m)
-      dp[i].assign(n, 0);
+    dp.assign(a.size(), vector(a[0].size(), 0));
     this->a = a;
     int s = 0;
-    REP(i, m)
-      REP(j, n)
-        if (! dp[i][j])
-          s = max(s, dfs(i, j));
+    REP(i, a.size())
+      REP(j, a[0].size())
+        s = max(s, dfs(i, j));
     return s;
   }
 };

shopping-offer.cc

@@ -0,0 +1,22 @@
+// Shopping Offers
+// memoization
+class Solution {
+  map<vector<int>, int> memo;
+public:
+  int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
+    auto r = memo.try_emplace(needs);
+    if (!r.second)
+      return r.first->second;
+    int ans = inner_product(needs.begin(), needs.end(), price.begin(), 0);
+    for (auto &s: special) {
+      vector<int> needs1 = needs;
+      int i = 0;
+      for (; i < needs.size(); i++)
+        if ((needs1[i] -= s[i]) < 0)
+          break;
+      if (i == needs.size())
+        ans = min(ans, s[i] + shoppingOffers(price, special, needs1));
+    }
+    return r.first->second = ans;
+  }
+};