Add files via upload

Author: dolphingarlic

COI/COCI 21-alias.cpp

@@ -0,0 +1,57 @@
+/*
+COCI 2021 Alias
+- Map each word to an integer, and do Dijkstra's
+- Complexity: O(QN log N)
+*/
+
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+map<string, int> mp;
+vector<pair<int, ll>> graph[1000];
+ll visited[1000];
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    int n, m, cnt = 0;
+    cin >> n >> m;
+    while (m--) {
+        string s, t;
+        ll v;
+        cin >> s >> t >> v;
+        if (!mp.count(s)) mp[s] = cnt++;
+        if (!mp.count(t)) mp[t] = cnt++;
+        graph[mp[s]].push_back({mp[t], v});
+    }
+    int q;
+    cin >> q;
+    while (q--) {
+        string s, t;
+        cin >> s >> t;
+        int src = mp[s], dest = mp[t];
+        memset(visited, 0x3f, sizeof visited);
+        priority_queue<pair<ll, int>> pq;
+        visited[src] = 0;
+        pq.push({0, src});
+        bool found = false;
+        while (pq.size()) {
+            ll cost;
+            int node;
+            tie(cost, node) = pq.top();
+            pq.pop();
+            if (-cost != visited[node]) continue;
+            if (node == dest) {
+                found = true;
+                cout << -cost << '\n';
+                break;
+            }
+            for (pair<int, ll> i : graph[node]) if (i.second - cost < visited[i.first]) {
+                visited[i.first] = i.second - cost;
+                pq.push({cost - i.second, i.first});
+            }
+        }
+        if (!found) cout << "Roger\n";
+    }
+    return 0;
+}

COI/COCI 21-anagramistica.cpp

@@ -0,0 +1,60 @@
+/*
+COCI 2021 Anagramistica
+- Sort each word and accumulate a frequency table
+- dp[i][j] = Ways to choose from the first i types of words
+             and have j similar pairs
+           = sum(dp[i - 1][j - (k choose 2)] * (cnt[i] choose k))
+- Complexity: O(NK * sqrt(N))?
+*/
+
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+const ll MOD = 1e9 + 7;
+
+ll expo(ll base, ll pow) {
+    ll ans = 1;
+    while (pow) {
+        if (pow & 1) ans = ans * base % MOD;
+        pow >>= 1;
+        base = base * base % MOD;
+    }
+    return ans;
+}
+
+ll fact[2001], chs[2001], dp[2001][2001];
+map<string, int> mp;
+int cnt[2001];
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    int n, k;
+    cin >> n >> k;
+    fact[0] = 1;
+    for (int i = 1; i <= k; i++) fact[i] = fact[i - 1] * i % MOD;
+    while (n--) {
+        string s;
+        cin >> s;
+        sort(s.begin(), s.end());
+        mp[s]++;
+    }
+    int m = 0;
+    for (auto i : mp) cnt[++m] = i.second;
+    dp[0][0] = 1;
+    for (int i = 1; i <= m; i++) {
+        chs[0] = 1;
+        for (int j = 1; j <= cnt[i]; j++)
+            chs[j] = chs[j - 1] * (cnt[i] - j + 1) % MOD * expo(j, MOD - 2) % MOD;
+
+        for (int j = 0; j <= k; j++) {
+            for (int l = 0; l <= cnt[i]; l++) {
+                if (l * (l - 1) / 2 > j) break;
+                dp[i][j] += dp[i - 1][j - l * (l - 1) / 2] * chs[l] % MOD;
+                if (dp[i][j] >= MOD) dp[i][j] -= MOD;
+            }
+        }
+    }
+    cout << dp[m][k];
+    return 0;
+}

COI/COCI 21-bold.cpp

@@ -0,0 +1,21 @@
+/*
+COCI 2021 Bold
+- Just do it
+*/
+
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+string grid[100];
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    int n, m;
+    cin >> n >> m;
+    for (int i = 0; i < n; i++) cin >> grid[i];
+    for (int i = n - 2; ~i; i--) for (int j = m - 2; ~j; j--) if (grid[i][j] == '#')
+        grid[i][j + 1] = grid[i + 1][j] = grid[i + 1][j + 1] = '#';
+    for (int i = 0; i < n; i++) cout << grid[i] << '\n';
+    return 0;
+}

COI/COCI 21-index.cpp

@@ -0,0 +1,72 @@
+/*
+COCI 2021 Index
+- Let paper i be a point (i, p[i]) in the Cartesian plane
+- A query is basically finding the largest M such that the number of points
+  in the rectangle (l[j], 2e5)->(r[j], M) is at least M
+- We can binary search for M and use a persistent segment tree to do static
+  2D range sum queries
+- Complexity: O(N log^2 N)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+const int MX = 2e5 + 1;
+
+struct Node {
+    int l, r, cnt;
+    Node *lc, *rc;
+
+    Node(int x, int c = 0): l(x), r(x), cnt(c), lc(nullptr), rc(nullptr) {}
+    Node(Node *llc, Node *rrc) {
+        lc = llc, rc = rrc;
+        l = lc->l, r = rc->r;
+        cnt = lc->cnt + rc->cnt;
+    }
+};
+
+Node *build(int l = 1, int r = MX) {
+    if (l == r) return new Node(l);
+    int mid = (l + r) >> 1;
+    return new Node(build(l, mid), build(mid + 1, r));
+}
+
+Node *increment(Node *node, int pos, int l = 1, int r = MX) {
+    if (l == r) return new Node(l, node->cnt + 1);
+    int mid = (l + r) >> 1;
+    if (pos > mid) return new Node(node->lc, increment(node->rc, pos, mid + 1, r));
+    return new Node(increment(node->lc, pos, l, mid), node->rc);
+}
+
+int query(Node *node, int pos, int l = 1, int r = MX) {
+    if (r < pos) return 0;
+    if (l >= pos) return node->cnt;
+    int mid = (l + r) >> 1;
+    return query(node->lc, pos, l, mid) + query(node->rc, pos, mid + 1, r);
+}
+
+int n, q, p[MX];
+Node *persist_roots[MX];
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    cin >> n >> q;
+    for (int i = 1; i <= n; i++) cin >> p[i];
+    persist_roots[0] = build();
+    for (int i = 1; i <= n; i++) persist_roots[i] = increment(persist_roots[i - 1], p[i]);
+
+    while (q--) {
+        int x, y;
+        cin >> x >> y;
+        int l = 1, r = y - x + 1;
+        while (l != r) {
+            int mid = (l + r + 1) >> 1;
+            if (query(persist_roots[y], mid) - query(persist_roots[x - 1], mid) >= mid)
+                l = mid;
+            else
+                r = mid - 1;
+        }
+        cout << l << '\n';
+    }
+    return 0;
+}