A bunch of problems

Author: dolphingarlic

APIO/APIO 15-skyscrapers.cpp

@@ -1,85 +1,54 @@
-#include <iostream>
-#include <queue>
-#include <set>
-#include <vector>
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
 using namespace std;
-priority_queue<pair<int, int>> q1;
-const int MAXN = 30010;
-set<int> v1[MAXN];
-vector<pair<int, int>> g[MAXN];
-bool visited[MAXN];
-int dp[MAXN];
-int target;
- 
-int first, jump;
+
+set<int> doges[30000];
+vector<pair<int, int>> graph[30000];
+int visited[30000];
+
 int main() {
-    int n, m;
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    int n, m, src, dest;
     cin >> n >> m;
-    for (int i = 0; i < m; i++) {
+    FOR(i, 0, m) {
         int b, p;
         cin >> b >> p;
-        if (i == 0) {
-            first = b;
-            jump = p;
-        }
-        if (i == 1) {
-            target = b;
-        }
- 
-        v1[b].insert(p);
+        if (!i) src = b;
+        if (i == 1) dest = b;
+        doges[b].insert(p);
     }
-    for (int i = 0; i <= n; i++) {
-        for (int x : v1[i]) {
-            int b = i;
-            int p = x;
-            int count = 1;
-            for (int j = b + p; j <= n; j += p) {
-                if (v1[j].find(p) != v1[j].end()) {
-                    g[b].push_back(make_pair(j, count));
-                    break;
-                }
-                g[b].push_back(make_pair(j, count));
-                count++;
+
+    FOR(i, 0, n) {
+        for (int j : doges[i]) {
+            for (int k = i + j, cnt = 1; k < n; k += j, cnt++) {
+                graph[i].push_back({k, cnt});
+                if (doges[k].find(j) != doges[k].end()) break;
             }
-            count = 1;
-            for (int j = b - p; j >= 0; j -= p) {
-                if (v1[j].find(p) != v1[j].end()) {
-                    g[b].push_back(make_pair(j, count));
-                    break;
-                }
-                g[b].push_back(make_pair(j, count));
-                count++;
+            for (int k = i - j, cnt = 1; k >= 0; k -= j, cnt++) {
+                graph[i].push_back({k, cnt});
+                if (doges[k].find(j) != doges[k].end()) break;
             }
         }
     }
-    q1.push(make_pair(0, first));
-    for (int i = 0; i <= n; i++) {
-        dp[i] = 1e9;
-    }
-    dp[first] = 0;
- 
-    while (!q1.empty()) {
-        auto hold = q1.top();
-        int skyscraper = hold.second;
-        int dist = -1 * hold.first;
- 
-        q1.pop();
-        if (skyscraper == target) {
-            cout << dist << endl;
-            return 0;
-        }
-        if (visited[skyscraper]) {
-            continue;
-        }
-        visited[skyscraper] = true;
-        for (auto x : g[skyscraper]) {
-            int w = x.second;
-            int to = x.first;
-            if (dp[to] > dp[skyscraper] + w) {
-                dp[to] = dp[skyscraper] + w;
-                q1.push(make_pair(-1 * dp[to], to));
+
+    memset(visited, 0x3f, sizeof visited);
+    priority_queue<pair<int, int>> pq;
+    pq.push({0, src});
+    visited[src] = 0;
+    while (pq.size()) {
+        int dist, node;
+        tie(dist, node) = pq.top();
+        pq.pop();
+        if (node == dest) return cout << -dist, 0;
+        for (pair<int, int> i : graph[node]) {
+            if (i.second - dist < visited[i.first]) {
+                visited[i.first] = i.second - dist;
+                pq.push({dist - i.second, i.first});
             }
         }
     }
-    cout << -1 << endl;
+    cout << -1;
+    return 0;
 }

CEOI/CEOI 16-match.cpp

@@ -0,0 +1,50 @@
+/*
+CEOI 2016 Match
+- Let match(i, j) = Can we make a balanced bracket sequence from s[i:j]?
+- First, check if match(0, N - 1) and print -1 if not
+- Next, notice how we want to match opening brackets as late as possible
+    - This means that given s[i:j] where match(i, j), s[i] matches with
+      the greatest k such that match(k + 1, j) and s[k] == s[i]
+- Let opt[j][c] = The greatest k such that match(k + 1, j) and s[k] == c
+                = j                                 if s[j] == c,
+                  opt[opt[j - 1][s[j]] - 1][c]      if j > 0 and opt[j - 1][s[j]] > 0
+                  -1                                otherwise
+- Clearly, this can be precomputed in O(26N) time and memory
+- Now we can recursively solve for the optimal string, since we know we match
+  s[i] with s[opt[j][s[i]]] for the substring s[i:j]
+- Complexity: O(26N)
+*/
+
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
+using namespace std;
+
+string s;
+int n, opt[100000][26];
+char ans[100000];
+
+string solve(int l = 0, int r = n - 1) {
+    if (l > r) return "";
+    return '(' + solve(l + 1, opt[r][s[l] - 'a'] - 1) + ')' + solve(opt[r][s[l] - 'a'] + 1, r);
+}
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    cin >> s;
+    n = s.size();
+    stack<char> stck;
+    FOR(i, 0, n) {
+        if (stck.size() && s[i] == stck.top()) stck.pop();
+        else stck.push(s[i]);
+        FOR(j, 0, 26) {
+            if (j == s[i] - 'a') opt[i][j] = i;
+            else if (i && opt[i - 1][s[i] - 'a']) opt[i][j] = opt[opt[i - 1][s[i] - 'a'] - 1][j];
+            else opt[i][j] = -1;
+        }
+    }
+    if (stck.size()) return cout << -1, 0;
+    cout << solve();
+    return 0;
+}

COI/COCI 08-periodni.cpp

@@ -0,0 +1,105 @@
+/*
+COCI 2008 Periodni
+- Notice how if we move from the y row upward, we get "islands" forming
+    - Each island is independent and is also a smaller periodic table
+    - This suggests that since the periodic table has no "donuts", we should
+      compress it into a rooted tree
+        - Kinda like IOI 2012 Ideal City
+- The root node of a periodic table is the largest rectangle we can make from
+  the y few rows
+    - We can then recursively generate the rest of the tree
+- dp[i][j] = The number of ways to put j noble gases in node i's subtree
+- tmp[i][j] = dp[i][j] but we put no noble gases in node i
+- dp[i][j] = sum(tmp[i][k] * choose(width[i] - k, j) * choose(height[i], j) * j!)
+- Complexity: O(N^2 * K)
+*/
+
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
+using namespace std;
+
+const ll MOD = 1e9 + 7;
+
+int n, m = 0, k, h[500];
+ll fact[1000001]{1}, inv_fact[1000001]{1};
+ll width[500], height[500], dp[500][501], tmp[501];
+vector<int> graph[500];
+
+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 choose(ll x, ll y) {
+    if (x < y) return 0;
+    return fact[x] * inv_fact[y] % MOD * inv_fact[x - y] % MOD;
+}
+
+void construct_tree(int l = 0, int r = n - 1, int dh = 0) {
+    int min_h = *min_element(h + l, h + r + 1);
+    width[m] = r - l + 1;
+    height[m] = min_h - dh;
+
+    int curr_idx = m++, curr_l = l;
+    FOR(i, l, r + 1) {
+        if (h[i] == min_h) {
+            if (curr_l != i) {
+                graph[curr_idx].push_back(m);
+                construct_tree(curr_l, i - 1, min_h);
+            }
+            curr_l = i + 1;
+        }
+    }
+    if (curr_l != r + 1) {
+        graph[curr_idx].push_back(m);
+        construct_tree(curr_l, r, min_h);
+    }
+}
+
+void dfs(int node = 0) {
+    dp[node][0] = 1;
+    for (int i : graph[node]) {
+        dfs(i);
+        memset(tmp, 0, sizeof tmp);
+        FOR(j, 0, width[node] + 1) {
+            FOR(k, 0, width[i] + 1) {
+                if (j + k > width[node]) continue;
+                (tmp[j + k] += dp[node][j] * dp[i][k]) %= MOD;
+            }
+        }
+        FOR(j, 0, width[node] + 1) dp[node][j] = tmp[j];
+    }
+
+    memset(tmp, 0, sizeof tmp);
+    FOR(i, 0, width[node] + 1) {
+        FOR(j, 0, width[node] + 1) {
+            if (i + j > width[node]) continue;
+            ll x = dp[node][i];
+            ll y = choose(width[node] - i, j) * choose(height[node], j) % MOD * fact[j] % MOD;
+            (tmp[i + j] += x * y) %= MOD;
+        }
+    }
+    FOR(i, 0, width[node] + 1) dp[node][i] = tmp[i];
+}
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    FOR(i, 1, 1000001) {
+        fact[i] = fact[i - 1] * i % MOD;
+        inv_fact[i] = expo(fact[i], MOD - 2);
+    }
+
+    cin >> n >> k;
+    FOR(i, 0, n) cin >> h[i];
+    construct_tree();
+    dfs();
+    cout << dp[0][k];
+    return 0;
+}

LMIO/LMIO 17-ones.cpp LMIO/LMIO 17-vinetai.cppLMIO/LMIO 17-ones.cpp renamed to LMIO/LMIO 17-vinetai.cpp

@@ -0,0 +1,51 @@
+/*
+LMIO 2018 Menesinis Bilietas
+- DSU
+- Complexity: O(N)
+*/
+
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
+using namespace std;
+
+int cmp[500001], cmp_cnt;
+set<int> graph[500001];
+
+int find(int A) {
+    while (A != cmp[A]) cmp[A] = cmp[cmp[A]], A = cmp[A];
+    return A;
+}
+
+void onion(int A, int B) {
+    if (find(A) == find(B)) return;
+    cmp[find(A)] = find(B);
+    cmp_cnt--;
+}
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    int n, m;
+    cin >> n >> m;
+    iota(cmp, cmp + n + 1, 0);
+    cmp_cnt = n;
+    vector<pair<int, int>> bus;
+    while (m--) {
+        int u, v;
+        char t;
+        cin >> u >> v >> t;
+        if (t == 'A') bus.push_back({u, v});
+        else onion(u, v);
+    }
+    for (pair<int, int> i : bus) {
+        if (find(i.first) == find(i.second)) continue;
+        graph[find(i.first)].insert(find(i.second));
+        graph[find(i.second)].insert(find(i.first));
+    }
+
+    int ans = 0;
+    FOR(i, 1, n + 1) if (graph[find(i)].size() == cmp_cnt - 1) ans++;
+    cout << ans;
+    return 0;
+}

LMIO/LMIO 18-menesinis_bilietas.cpp

@@ -0,0 +1,40 @@
+/*
+LMIO 2018 Pigus Skrydziai
+- We either take all edges incident to one node or we take a triangle
+- Complexity: O(N log N)
+*/
+
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
+using namespace std;
+
+ll prof[300001];
+vector<pair<ll, int>> graph[300001];
+map<pair<int, int>, ll> edges;
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    int n, m;
+    cin >> n >> m;
+    while (m--) {
+        int a, b;
+        ll v;
+        cin >> a >> b >> v;
+        prof[a] += v, prof[b] += v;
+        graph[a].push_back({v, b});
+        graph[b].push_back({v, a});
+        edges[{a, b}] = edges[{b, a}] = v;
+    }
+    ll ans = *max_element(prof + 1, prof + n + 1);
+    FOR(i, 1, n + 1) {
+        sort(graph[i].begin(), graph[i].end(), greater<pair<ll, int>>());
+        if (graph[i].size() > 1) {
+            ans = max(ans, graph[i][0].first + graph[i][1].first +
+                               edges[{graph[i][0].second, graph[i][1].second}]);
+        }
+    }
+    cout << ans;
+    return 0;
+}

LMIO/LMIO 18-pigus_skrydziai.cpp

@@ -1,8 +1,8 @@
 /*
 LMIO 2019 Bulves
 - We want to transform the arrays A so that A[i] >= B[i] for each i
-    - This means if we define the array C[i] = A[i] - B[i], then C is a
-      non-decreasing sequence and 0 <= C[i] <= C[N]
+    - This means if we define the array C[i] = A[i] - B[i], then C must become a
+      non-decreasing sequence with 0 <= C[i] <= C[N]
 - Notice how each time we move a fertilizer to an adjacent position, exactly
   1 element of C changes and we increment the cost by 1
 - This problem thus turns into https://codeforces.com/contest/713/problem/C and