new: IEEEXtreme 15 & 18

Author: omar-besbes

solutions/IEEEXtreme 15/Bus_Company.cpp solutions/IEEEXtreme/IEEEXtreme 15/Bus_Company.cpp

@@ -0,0 +1,66 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+
+const int N = 1e6 + 3;
+ll nextu[N];
+ll vis[N];
+
+void dfs(int n, vector<ll>& v) {
+   if (vis[n]) return;
+   vis[n] = 1;
+   v.push_back(n);
+   dfs(nextu[n], v);
+}
+
+void solve() {
+   ll n, x;
+   cin >> n >> x;
+   ll a[n];
+
+   for (int i = 0; i < n; i++) cin >> a[i];
+   sort(a, a + n, greater<ll>());
+
+   ll start = 0, mini = 0, end = 0;
+
+   while (end < n - 1) {
+      // cout << start << " " << end << endl;
+      if ((a[end + 1] + x) <= a[start]) {
+         nextu[start] = end + 1;
+         start++;
+         end++;
+      } else {
+         end++;
+      }
+   }
+   // for (int i = 0; i < n; i++) cout << nextu[i] << " ";
+   vector<vector<ll>> aa;
+   for (int i = 0; i < n; i++) {
+      vector<ll> v;
+      dfs(i, v);
+      if (v.size() > 0) {
+         aa.push_back(v);
+      }
+   }
+   cout << aa.size() << endl;
+   for (auto& y : aa) {
+      cout << y.size() << " ";
+      for (int i : y) {
+         cout << a[i] << " ";
+      }
+      cout << endl;
+   }
+}
+
+int main() {
+   ios::sync_with_stdio(false);
+   cin.tie(0);
+
+   int t = 1;
+   // cin >> t;
+   while (t--) {
+      solve();
+   }
+
+   return 0;
+}

solutions/IEEEXtreme 15/Doctor.cpp solutions/IEEEXtreme/IEEEXtreme 15/Doctor.cpp

@@ -0,0 +1,91 @@
+#include <bits/stdc++.h>
+#pragma GCC optimization ("O2")
+using namespace std;
+typedef long long ll;
+const ll mod = 1e9 + 7;
+
+struct Hashing {
+   vector<vector<ll>> p, pref;
+   // assuming s is only composed of a-z characters
+   Hashing(const string &s) {
+      int n = s.length();
+      // change if s contains other chars than a-z
+      // primes should be greater than number of possible characters
+      vector primes{31, 37};
+      p.assign(primes.size(), vector<ll>(n + 1));
+      pref.assign(primes.size(), vector<ll>(n + 1));
+      for (int i = 0; i < primes.size(); i++) p[i][0] = 1, p[i][1] = primes[i];
+      for (int i = 0; i < p.size(); i++) {
+         p[i].resize(n + 1);
+         for (int j = 0; j < n; j++) {
+            // change here if s contains other chars than a-z
+            int c = s[j] - 'a' + 1;
+            pref[i][j + 1] = (pref[i][j] + c * p[i][j]) % mod;
+            p[i][j + 1] = p[i][j] * p[i][1] % mod;
+         }
+      }
+   }
+   // hash of s[l..r] inclusive for l & r
+   vector<ll> get(int l, int r) {
+      int n = p[0].size() - 1;
+      vector<ll> ans(p.size());
+      for (int i = 0; i < p.size(); i++) {
+         ans[i] = (pref[i][r + 1] - pref[i][l] + mod) % mod;
+         ans[i] = ans[i] * p[i][n - l] % mod;
+      }
+      return ans;
+   }
+   bool compare(pair<int, int> r1, pair<int, int> r2) {
+      auto res1 = get(r1.first, r1.second);
+      auto res2 = get(r2.first, r2.second);
+      for (int i = 0; i < p.size(); i++)
+         if (res1[i] != res2[i]) return false;
+      return true;
+   }
+};
+
+int main() {
+   string s;
+   cin >> s;
+   int n = s.length();
+   auto h = Hashing(s);
+   unordered_map<ll, vector<pair<int, int>>> a;
+   unordered_map<ll, int> sz;
+   for (int r = 0; r < n; r++) {
+      for (int l = 0; l <= r; l++) {
+         auto tmp = h.get(l, r);
+         ll hash = tmp[0] + mod * tmp[1];
+         sz[hash] = r - l + 1;
+         a[hash].push_back({l, r});
+      }
+   }
+
+   auto getNbComponents = [&](vector<pair<int, int>> &a) {
+      sort(a.begin(), a.end());
+      int curl = 0, curr = 0, ans = 1;
+      for (auto [l, r] : a) {
+         if (l > curr) {
+            ans += l - curr;
+            curl = l, curr = r;
+         } else {
+            curr = max(curr, r);
+         }
+      }
+      ans += (n - 1) - curr;
+      return ans;
+   };
+
+   vector<vector<int>> v(n + 1);
+   for (auto [hash, ranges] : a) {
+      v[sz[hash]].push_back(getNbComponents(ranges));
+   }
+
+   vector<int> ans(n + 1, 0);
+   for (int len = n; len >= 0; len--) {
+      for (auto nb : v[len]) {
+         ans[nb] = len;
+      }
+   }
+
+   for (int i = 1; i <= n; i++) cout << ans[i] << " ";
+}

solutions/IEEEXtreme 15/Language_Learning.cpp solutions/IEEEXtreme/IEEEXtreme 15/Language_Learning.cpp

@@ -0,0 +1,182 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+
+pair<ll, int> operator+(const pair<ll, int> &a, const pair<ll, int> &b) {
+   return {a.first + b.first, a.second + b.second};
+}
+
+int n, q;
+
+struct SegTree {
+   vector<ll> t, maxT, minT, lazyAdd, lazyReplace;
+   vector<bool> marked;
+   vector<int> happ, lazyHapp;
+   SegTree(vector<int> &a) {
+      marked.assign(4 * n, false);
+      lazyAdd.assign(4 * n, 0);
+      lazyReplace.assign(4 * n, 0);
+      happ.assign(4 * n, 0);
+      lazyHapp.assign(4 * n, 0);
+      t.resize(4 * n);
+      maxT.resize(4 * n);
+      minT.resize(4 * n);
+      build(a);
+   }
+   void build(vector<int> &a, int v = 1, int l = 0, int r = n - 1) {
+      if (l == r) {
+         t[v] = a[l];
+         maxT[v] = t[v];
+         minT[v] = t[v];
+      } else {
+         int m = (l + r) / 2;
+         build(a, 2 * v, l, m);
+         build(a, 2 * v + 1, m + 1, r);
+         t[v] = t[2 * v] + t[2 * v + 1];
+         maxT[v] = max(maxT[2 * v], maxT[2 * v + 1]);
+         minT[v] = max(minT[2 * v], minT[2 * v + 1]);
+      }
+   }
+   void compose(int p, int c) {
+      if (marked[p]) {
+         lazyAdd[c] = lazyAdd[p];
+         lazyReplace[c] = lazyAdd[p];
+         marked[c] = true;
+      } else {
+         lazyAdd[c] += lazyAdd[p];
+      }
+
+      lazyHapp[c] += lazyHapp[p];
+   }
+   void push(int v, int l, int r) {
+      int m = (l + r) / 2;
+      if (marked[v]) {
+         t[v] = (r - l + 1) * lazyReplace[v];
+         maxT[v] = minT[v] = lazyReplace[v];
+      }
+
+      t[v] += (r - l + 1) * lazyAdd[v];
+      maxT[v] = max(maxT[v], maxT[v] + lazyAdd[v]);
+      minT[v] = max(minT[v], minT[v] + lazyAdd[v]);
+      happ[v] += (r - l + 1) * lazyHapp[v];
+
+      if (l != r) {
+         compose(v, 2 * v);
+         compose(v, 2 * v + 1);
+      }
+
+      marked[v] = false;
+      lazyAdd[v] = 0;
+      lazyHapp[v] = 0;
+   }
+   void add(int a, int b, int c, int v = 1, int l = 0, int r = n - 1) {
+      if (a > b || a > r || b < l) return;
+      if (a == l && b == r) {
+         lazyAdd[v] += c;
+         if (c > 0)
+            lazyHapp[v]++;
+         else
+            lazyHapp[v]--;
+         return;
+      }
+      push(v, l, r);
+      int m = (l + r) / 2;
+      add(a, min(b, m), c, 2 * v, l, m);
+      add(max(a, m + 1), b, c, 2 * v + 1, m + 1, r);
+      push(2 * v, l, m);
+      push(2 * v + 1, m + 1, r);
+      t[v] = t[2 * v] + t[2 * v + 1];
+      maxT[v] = max(maxT[2 * v], maxT[2 * v + 1]);
+      minT[v] = max(minT[2 * v], minT[2 * v + 1]);
+      happ[v] = happ[2 * v] + happ[2 * v + 1];
+   }
+   void replace(int a, int b, int c, int v = 1, int l = 0, int r = n - 1) {
+      if (a > b || a > r || b < l) return;
+      if (a == l && b == r &&
+          (c > maxT[v] + lazyAdd[v] || c < minT[v] + lazyAdd[v] || l == r)) {
+         if (c > maxT[v] + lazyAdd[v])
+            lazyHapp[v]++;
+         else if (c < minT[v] + lazyAdd[v])
+            lazyHapp[v]--;
+         else
+            lazyHapp[v] += c > t[v] + lazyAdd[v] ? 1 : -1;
+         lazyReplace[v] = c;
+         lazyAdd[v] = 0;
+         marked[v] = true;
+         return;
+      }
+      push(v, l, r);
+      int m = (l + r) / 2;
+      replace(a, min(b, m), c, 2 * v, l, m);
+      replace(max(a, m + 1), b, c, 2 * v + 1, m + 1, r);
+      push(2 * v, l, m);
+      push(2 * v + 1, m + 1, r);
+      t[v] = t[2 * v] + t[2 * v + 1];
+      maxT[v] = max(maxT[2 * v], maxT[2 * v + 1]);
+      minT[v] = max(minT[2 * v], minT[2 * v + 1]);
+      happ[v] = happ[2 * v] + happ[2 * v + 1];
+   }
+   pair<ll, int> query(int a, int b, int v = 1, int l = 0, int r = n - 1) {
+      if (a > b || a > r || b < l) return make_pair(0LL, 0);
+      push(v, l, r);
+      if (a == l && b == r) return make_pair(t[v], happ[v]);
+      int m = (l + r) / 2;
+      auto ql = query(a, min(b, m), 2 * v, l, m);
+      auto qr = query(max(a, m + 1), b, 2 * v + 1, m + 1, r);
+      return ql + qr;
+   }
+   void print() {
+      queue<tuple<int, int, int>> q, tmp;
+      q.push({1, 0, n - 1});
+      while (!q.empty()) {
+         while (!q.empty()) {
+            auto [v, l, r] = q.front();
+            cout << "(" << t[v] << "," << lazyAdd[v] << "," << lazyReplace[v]
+                 << "," << happ[v] << "," << lazyHapp[v] << ") ";
+            q.pop();
+
+            if (l < r) {
+               int m = (l + r) / 2;
+               tmp.push({2 * v, l, m});
+               tmp.push({2 * v + 1, m + 1, r});
+            }
+         }
+         cout << "\n";
+         q.swap(tmp);
+      }
+      cout << "\n\n";
+   }
+};
+
+int main() {
+   ios::sync_with_stdio(false);
+   cin.tie(0);
+   cout.tie(0);
+
+   cin >> n >> q;
+   vector<int> a(n);
+   for (auto &i : a) cin >> i;
+   SegTree st(a);
+
+   while (q--) {
+      int type, l, r, c;
+      cin >> type;
+      if (type <= 1) {
+         cin >> l >> r >> c;
+         l--, r--;
+         if (type == 0)
+            st.replace(l, r, c);
+         else
+            st.add(l, r, c);
+      } else {
+         cin >> l >> r;
+         l--, r--;
+         auto [sal, hap] = st.query(l, r);
+         ll ans = type == 2 ? sal : hap;
+         ll len = r - l + 1;
+         auto g = gcd(abs(ans), len);
+         cout << ans / g << "/" << len / g << "\n";
+      }
+      // st.print();
+   }
+}

solutions/IEEEXtreme 15/Similarity.cpp solutions/IEEEXtreme/IEEEXtreme 15/Similarity.cpp

@@ -0,0 +1,46 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+
+void solve() {
+   string s;
+   cin >> s;
+   ll count = 0, maxi = 0, mini = 0;
+   ll n = s.size();
+   ll b, a = 0;
+   for (int i = 0; i < n; i++) {
+      if (s[i] == 'U')
+         count++;
+      else if (s[i] == 'L')
+         count--;
+      maxi = max(maxi, count);
+      mini = min(mini, count);
+   }
+   if (count > 0) {
+      b = mini - 1;
+      mini--;
+   } else {
+      b = maxi + 1;
+      maxi++;
+   }
+   if (b == maxi)
+      b = 1;
+   else
+      b = maxi - mini + 1;
+   cout << maxi - mini + 1 << " " << maxi + 1 << " " << b << endl;
+   for (int i = 1; i < maxi - mini + 1; i++) {
+      cout << i + 1 << " " << 0 << endl;
+   }
+   cout << "0 0" << endl;
+}
+
+int main() {
+   ios::sync_with_stdio(false);
+   cin.tie(0);
+
+   int t = 1;
+   // cin >> t;
+   while (t--) {
+      solve();
+   }
+}