misc

Author: MaskRay

apply-operations-to-an-array.cc

@@ -0,0 +1,18 @@
+// Apply Operations to an Array
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  vector<int> applyOperations(vector<int>& a) {
+    int n = a.size();
+    REP(i, n-1)
+      if (a[i] == a[i+1])
+        a[i]*=2, a[i+1]=0;
+    int j = 0;
+    REP(i, n)
+      if (a[i])
+        a[j++] = a[i];
+    fill(a.begin()+j, a.end(), 0);
+    return a;
+  }
+};

divide-intervals-into-minimum-number-of-groups.cc

@@ -0,0 +1,21 @@
+// Divide Intervals Into Minimum Number of Groups
+#define ALL(x) (x).begin(), (x).end()
+using pii = pair<int, int>;
+
+class Solution {
+public:
+  int minGroups(vector<vector<int>>& a) {
+    vector<pii> b;
+    int s = 0, c = 0;
+    for (auto &x : a) {
+      b.emplace_back(x[0], 1);
+      b.emplace_back(x[1]+1, -1);
+    }
+    sort(ALL(b));
+    for (auto [x, d] : b) {
+      c += d;
+      s = max(s, c);
+    }
+    return s;
+  }
+};

find-all-good-indices.cc

@@ -0,0 +1,24 @@
+// Find All Good Indices
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
+#define ROF(i, a, b) for (long i = (b); --i >= (a); )
+
+class Solution {
+public:
+  vector<int> goodIndices(vector<int>& a, int k) {
+    int n = a.size(), s = 1;
+    vector<int> b(n), r;
+    ROF(i, 0, n-1) {
+      b[i] = s;
+      if (a[i] <= a[i+1]) s++;
+      else s = 1;
+    }
+    s = 1;
+    FOR(i, 1, n) {
+      if (min(b[i], s) >= k)
+        r.push_back(i);
+      if (a[i-1] >= a[i]) s++;
+      else s = 1;
+    }
+    return r;
+  }
+};

find-the-original-array-of-prefix-xor.cc

@@ -0,0 +1,14 @@
+// Find The Original Array of Prefix Xor
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
+
+class Solution {
+public:
+  vector<int> findArray(vector<int>& pref) {
+    int n = pref.size();
+    vector<int> a(n);
+    a[0] = pref[0];
+    FOR(i, 1, n)
+      a[i] = pref[i-1] ^ pref[i];
+    return a;
+  }
+};

length-of-the-longest-alphabetical-continuous-substring.cc

@@ -0,0 +1,13 @@
+// Length of the Longest Alphabetical Continuous Substring
+class Solution {
+public:
+  int longestContinuousSubstring(string s) {
+    int n = s.size(), r = 0;
+    for (int j = 0, i = 0; i < n; ) {
+      for (; j<n && s[i]==s[j]-(j-i); j++);
+      r = max(r, j-i);
+      i = j;
+    }
+    return min(r, 26);
+  }
+};

longest-subarray-with-maximum-bitwise-and.cc

@@ -0,0 +1,15 @@
+// Longest Subarray With Maximum Bitwise AND
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  int longestSubarray(vector<int>& a) {
+    int n = a.size(), x = *max_element(ALL(a)), c = 0, r = 0;
+    for (int v: a)
+      if (v != x)
+        c = 0;
+      else
+        r = max(r, ++c);
+    return r;
+  }
+};

maximum-deletions-on-a-string.cc

@@ -0,0 +1,23 @@
+// Maximum Deletions on a String
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
+#define ROF(i, a, b) for (long i = (b); --i >= (a); )
+
+class Solution {
+public:
+  int deleteString(string a) {
+    int n = a.size();
+    vector<int> dp(n+1);
+    ROF(i, 0, n) {
+      dp[i] = 1;
+      int mx = (int(i)+n)/2+1;
+      FOR(j, i+1, mx) {
+        if (dp[j] < dp[i]) continue;
+        int k = 0;
+        for (; i+k < j && a[i+k] == a[j+k]; k++);
+        if (i+k == j)
+          dp[i] = dp[j]+1;
+      }
+    }
+    return dp[0];
+  }
+};

maximum-sum-of-an-hourglass.cc

@@ -0,0 +1,16 @@
+// Maximum Sum of an Hourglass
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  int maxSum(vector<vector<int>>& a) {
+    int m = a.size(), n = a[0].size(), s = 0;
+    REP(i, m-2)
+      REP(j, n-2) {
+        s = max(s, a[i][j]+a[i][j+1]+a[i][j+2] + 
+                a[i+1][j+1]+
+                a[i+2][j]+a[i+2][j+1]+a[i+2][j+2]);
+      }
+    return s;
+  }
+};

maximum-sum-of-distinct-subarrays-with-length-k.cc

@@ -0,0 +1,31 @@
+// Maximum Sum of Distinct Subarrays With Length K
+#define FOR(i, a, b) for (long i = (a); i < (b); i++)
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+class Solution {
+public:
+  long long maximumSubarraySum(vector<int>& a, int k) {
+    long n = a.size(), s = 0, sum = 0;
+    unordered_map<int, int> mm;
+    vector<int> c(n+1);
+    REP(i, k-1) {
+      int &t = mm[a[i]];
+      c[t]--;
+      c[++t]++;
+      sum += a[i];
+    }
+    FOR(i, k-1, n) {
+      int &t = mm[a[i]];
+      c[t]--;
+      c[++t]++;
+      sum += a[i];
+      if (c[1] == k)
+        s = max(s, sum);
+      int &t1 = mm[a[i-k+1]];
+      c[t1]--;
+      c[--t1]++;
+      sum -= a[i-k+1];
+    }
+    return s;
+  }
+};

minimize-xor.cc

@@ -0,0 +1,13 @@
+// Minimize Xor
+class Solution {
+public:
+  int minimizeXor(int a, int b) {
+    int c = 0, t;
+    b = __builtin_popcount(b);
+    for (; a && b; a ^= t, b--)
+      c |= t = 1 << 31-__builtin_clz(a);
+    for (; b; b--)
+      c |= c+1 & ~c;
+    return c;
+  }
+};

minimum-total-distance-traveled.cc

@@ -0,0 +1,161 @@
+// Minimum Total Distance Traveled
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+namespace {
+const long N = 100, V = N*2+2;
+struct Edge { int v, c, w, next; } e[(N+N+N*N) << 1];
+long h[V], hsrc;
+int head[V], q[V], allo;
+bool vis[V];
+
+void insert(int u, int v, int c, int w) {
+  e[allo] = {v, c, w, head[u]};
+  head[u] = allo++;
+  e[allo] = {u, 0, -w, head[v]};
+  head[v] = allo++;
+}
+
+bool relabel(int n, int src, int sink) {
+  int hd = 0, tl = 1;
+  q[0] = sink;
+  fill_n(vis, n, false);
+  fill_n(h, n, LONG_MAX/2);
+  h[sink] = 0;
+  vis[sink] = true;
+  while (hd != tl) {
+    int u = q[hd++], v;
+    long t;
+    if (hd == n) hd = 0;
+    vis[u] = false;
+    for (int i = head[u]; i >= 0; i = e[i].next)
+      if (e[i^1].c && (t = h[u]-e[i].w) < h[v = e[i].v]) {
+        h[v] = t;
+        if (! vis[v]) {
+          vis[v] = true;
+          if (t <= h[hd != tl ? q[hd] : src])
+            hd == 0 && (hd = n), q[--hd] = v;
+          else
+            q[tl++] = v, tl == n && (tl = 0);
+        }
+      }
+  }
+  REP(u, n)
+    for (int i = head[u]; i >= 0; i = e[i].next)
+      e[i].w += h[e[i].v]-h[u];
+  hsrc += h[src];
+  return h[src] < LONG_MAX/2;
+}
+
+int augment(int sink, int u, int f) {
+  if (u == sink) return f;
+  vis[u] = true;
+  int old = f;
+  for (int i = head[u]; i >= 0; i = e[i].next)
+    if (e[i].c && ! vis[e[i].v] && ! e[i].w) {
+      int ff = augment(sink, e[i].v, min(f, e[i].c));
+      e[i].c -= ff;
+      e[i^1].c += ff;
+      if (! (f -= ff)) break;
+    }
+  return old-f;
+}
+}
+
+class Solution {
+public:
+  long long minimumTotalDistance(vector<int>& a, vector<vector<int>>& b) {
+    const int m = a.size(), n = b.size(), src = m+n, sink = src+1;
+    allo = 0;
+    fill_n(head, sink+1, -1);
+    REP(i, m)
+      insert(src, i, 1, 0);
+    REP(i, n)
+      insert(m+i, sink, b[i][1], 0);
+    REP(i, m)
+      REP(j, n)
+        insert(i, m+j, 1, abs(a[i]-b[j][0]));
+    fill_n(h, sink+1, 0);
+    hsrc = 0;
+    long w, cost = 0;
+    while (relabel(sink+1, src, sink))
+      while (fill_n(vis, sink+1, false), w = augment(sink, src, INT_MAX))
+        cost += w*hsrc;
+    return cost;
+  };
+};
+
+/// minimum-cost flow: successive shortest path algorithm
+
+#define ALL(x) (x).begin(), (x).end()
+#define REP(i, n) for (long i = 0; i < (n); i++)
+
+namespace {
+const int N = 100, V = N*2+2, E = N+N+N*N;
+struct Edge { int v, c, w, next; } e[E << 1];
+long h[V];
+int q[V], head[V], pre[V], allo;
+bool in[V];
+
+void insert(int u, int v, int c, int w) {
+  e[allo] = {v, c, w, head[u]};
+  head[u] = allo++;
+  e[allo] = {u, 0, -w, head[v]};
+  head[v] = allo++;
+}
+
+bool labelCorrecting(int n, int src, int sink) {
+  int *hd = q, *tl = q+1;
+  fill_n(in, n, false);
+  fill_n(h, n, LONG_MAX);
+  h[q[0] = src] = 0;
+  while (hd != tl) {
+    int u = *hd++;
+    if (hd == q+n) hd = q;
+    in[u] = false;
+    for (int i = head[u]; i >= 0; i = e[i].next)
+      if (e[i].c > 0 && h[u]+e[i].w < h[e[i].v]) {
+        h[e[i].v] = h[u]+e[i].w;
+        pre[e[i].v] = i;
+        if (! in[e[i].v]) {
+          *tl++ = e[i].v;
+          if (tl == q+n) tl = q;
+          in[e[i].v] = true;
+        }
+      }
+  }
+  return h[sink] < LONG_MAX;
+}
+
+long minCost(int n, int src, int sink) {
+  long cost = 0, flow = 0;
+  while (labelCorrecting(n, src, sink)) {
+    int f = INT_MAX;
+    for (int v = sink; v != src; v = e[pre[v]^1].v)
+      f = min(f, e[pre[v]].c);
+    for (int v = sink; v != src; v = e[pre[v]^1].v) {
+      e[pre[v]].c -= f;
+      e[pre[v]^1].c += f;
+    }
+    cost += f*h[sink];
+    flow += f;
+  }
+  return cost;
+}
+}
+
+class Solution {
+public:
+  long long minimumTotalDistance(vector<int>& a, vector<vector<int>>& b) {
+    const int m = a.size(), n = b.size(), src = m+n, sink = src+1;
+    allo = 0;
+    fill_n(head, sink+1, -1);
+    REP(i, m)
+      insert(src, i, 1, 0);
+    REP(i, n)
+      insert(m+i, sink, b[i][1], 0);
+    REP(i, m)
+      REP(j, n)
+        insert(i, m+j, 1, abs(a[i]-b[j][0]));
+    return minCost(sink+1, src, sink);
+  };
+};

most-frequent-even-element.cc

@@ -0,0 +1,17 @@
+// Most Frequent Even Element
+#define ALL(x) (x).begin(), (x).end()
+
+class Solution {
+public:
+  int mostFrequentEven(vector<int>& a) {
+    int n = a.size(), s = -1, c = 0;
+    sort(ALL(a));
+    for (int j = 0, i = 0; i < n; ) {
+      for (; j < n && a[i]==a[j]; j++);
+      if (j-i > c && a[i]%2==0)
+        c = j-i, s = a[i];
+      i = j;
+    }
+    return s;
+  }
+};

number-of-common-factors.cc

@@ -0,0 +1,12 @@
+// Number of Common Factors
+class Solution {
+public:
+  int commonFactors(int a, int b) {
+    int s = 0;
+    a = gcd(a, b);
+    for (int i = 1; i*i <= a; i++)
+      if (a%i == 0)
+        s++, s += i*i != a;
+    return s;
+  }
+};