Stuff

Author: dolphingarlic

Baltic/Baltic 15-edi.cpp

@@ -1,23 +1,15 @@
 /*
 Baltic 2015 Editor
-- Firstly, the last operation is always active
-- Secondly, if operation y can't undo x but operation z can
-  undo x where x < y < z, then z can undo y
-    - This means for each operation, we only care about the
-      most recent operation whose level is strictly less than
-      the current operation
-    - View the sequence as a tree now
-        - Connect each operation to the other operation
-          mentioned above
-        - This means we can use binary lifting to find which
-          operation to undo by also storing suffix minimums
-- Thirdly, if we view the sequence of numbers we get as a trie,
-  each operation moves us either up or down a single node
-    - This means only the current letter can be undone
-    - So if we undo operation x with operation y, the answer
-      for operation y is the answer for operation x - 1
-        - Operation x - 1 must be active after operation y,
-          so connect y with x - 1
+- Firstly, notice how if x can't undo y and z can't undo x, then z can't undo y.
+- Let each operation be a node.
+    - If undo operation x undoes operation y, draw an edge between x and y - 1 and let par[x] = y - 1.
+    - Notice how the answer for x is the answer for par[x].
+- Consider an undo operation z.
+    - If z can't undo x, then z can't undo any operation in the range (par[x], x].
+    - This is because par[x] + 1 is the most recent active operation x could undo and the states of the nodes (par[x] + 1, x] remain unchanged.
+    - This still holds when we undo some operations.
+- Therefore, the operation we undo must lie on some path from the most recent operation upwards.
+- We can use suffix minimums and binary lifting to find this operation.
 - Complexity: O(N log N)
 */
 

Innopolis/Innopolis 19-stones.cpp

@@ -0,0 +1,42 @@
+/*
+- It's optimal to fill a stove to its maximum capacity if we put any stones in it
+- So we place V stones in (S - 1) / V stoves and (S - 1) % V + 1 stones in 1 stove
+- Do DP to calculate the result quickly
+- Complexity: O(N^2)
+*/
+
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
+using namespace std;
+
+ll a[1001], dp[1001][1001][2][3];
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    ll n, s, v;
+    cin >> n >> s >> v;
+    FOR(i, 1, n) cin >> a[i];
+
+    if (s <= n / 2 * v) return cout << 0, 0;
+
+    ll to_fill = (s - 1) / v, rem = (s - 1) % v + 1;
+    memset(dp, 0x3f, sizeof(dp));
+    dp[0][0][0][0] = dp[0][1][0][1] = dp[0][0][1][2] = 0;
+
+    FOR(i, 1, n) FOR(j, 0, to_fill + 1) {
+        dp[i][j][0][0] = *min_element(dp[i - 1][j][0], dp[i - 1][j][0] + 3);
+        dp[i][j][1][0] = *min_element(dp[i - 1][j][1], dp[i - 1][j][1] + 3);
+
+        if (j) {
+            dp[i][j][0][1] = min(dp[i - 1][j - 1][0][0], dp[i - 1][j - 1][0][1] + a[i] * v * v);
+            dp[i][j][1][1] = min(dp[i - 1][j - 1][1][0], min(dp[i - 1][j - 1][1][1] + a[i] * v * v, dp[i - 1][j - 1][1][2] + a[i] * rem * v));
+        }
+
+        dp[i][j][1][2] = min(dp[i - 1][j][0][0], dp[i - 1][j][0][1] + a[i] * rem * v);
+    }
+
+    cout << *min_element(dp[n - 1][to_fill][1], dp[n - 1][to_fill][1] + 3) << '\n';
+    return 0;
+}

infoarena/infoarena biconex.cpp

@@ -0,0 +1,60 @@
+/*
+Biconnected Components
+*/
+
+#include <bits/stdc++.h>
+#define FOR(i, x, y) for (int i = x; i < y; i++)
+typedef long long ll;
+using namespace std;
+
+vector<int> graph[100001], stck;
+vector<vector<int>> bccs;
+int low[100001], tin[100001], timer = 1;
+
+void dfs(int node = 1, int parent = 0) {
+    low[node] = tin[node] = timer++;
+    stck.push_back(node);
+
+    for (int i : graph[node]) if (i != parent) {
+        if (tin[i]) low[node] = min(low[node], tin[i]);
+        else {
+            dfs(i, node);
+            low[node] = min(low[node], low[i]);
+
+            if (low[i] >= tin[node]) {
+                bccs.push_back(vector<int>());
+                int lst = -1;
+                do {
+                    bccs.back().push_back(stck.back());
+                    lst = stck.back();
+                    stck.pop_back();
+                } while (!stck.empty() && lst != i);
+                bccs.back().push_back(node);
+            }
+        }
+    }
+}
+
+int main() {
+    ios_base::sync_with_stdio(0);
+    cin.tie(0);
+    ifstream cin("biconex.in");
+    ofstream cout("biconex.out");
+
+    int n, m;
+    cin >> n >> m;
+    FOR(i, 0, m) {
+        int u, v;
+        cin >> u >> v;
+        graph[u].push_back(v);
+        graph[v].push_back(u);
+    }
+    dfs();
+
+    cout << bccs.size() << '\n';
+    for (vector<int> i :  bccs) {
+        for (int j : i) cout << j << ' ';
+        cout << '\n';
+    }
+    return 0;
+}