Chinese problems

Author: dolphingarlic

Atcoder/ABC 141-F.cpp

@@ -0,0 +1,41 @@
+// Reference: https://math.stackexchange.com/questions/48682/maximization-with-xor-operator
+
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+ll a[100001], all_xor = 0;
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    int n;
+    cin >> n;
+    for (int i = 0; i < n; i++) {
+        cin >> a[i];
+        all_xor ^= a[i];
+    }
+    for (int i = 0; i < n; i++) a[i] &= ~all_xor;
+
+    for (int i = 59, j = 0; ~i; i--) {
+        int k = j;
+        // Find any a[k] with the i-th bit as 1
+        while (k < n && !(a[k] & (1ll << i))) k++;
+        if (k == n) continue;
+        // "Pivot" to make the i-th bit of a[j] also 1
+        if (k > j) a[j] ^= a[k];
+        k = j + 1;
+        while (k < n) {
+            // If a[k] has the i-th bit as 1, then it gets XORed with a[j]
+            // Otherwise, it stays the same
+            a[k] = min(a[k], a[k] ^ a[j]);
+            k++;
+        }
+        j++;
+    }
+    ll ans = 0;
+    // Now that the position of the most significant bit is different for each a[i],
+    // we can greedily take the max subset XOR
+    for (int i = 0; i < n; i++) ans = max(ans, ans ^ a[i]);
+    cout << ans * 2 + all_xor;
+    return 0;
+}

NOI.cn/NOI 09-treap.cpp

@@ -0,0 +1,50 @@
+/*
+NOI.cn 2009 Modified Treap
+- First, sort the nodes by their keys
+- Let dp[l][r][w] = Min cost to construct a BST with the nodes [l, r]
+                    such that the root's priority is at least w
+                  = min(
+                      { dp[l][m - 1][w] + dp[m + 1][r][w] + k : m from l to r },
+                      { dp[l][m - 1][p[m]] + dp[m + 1][r][p[m]] : m from l to r and p[m] >= w }
+                    ) + (Sum of frequencies of nodes [l, r])
+- Using memoization, this runs in O(N^4) time because w in our DP array
+  can only take on O(N) values (kinda like coordinate compression)
+- The first case of our DP transition is from changing the priority of node m
+- The second case of our DP transition is from not changing the priority
+  because we don't have to
+    - Note that we still need the other case because it may not be optimal not
+      to change the priority even if we don't have to
+- Complexity: O(N^4)
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int n;
+array<int, 3> node[71];
+int k, pref[71];
+unordered_map<int, int> dp[71][71];
+
+int solve(int l, int r, int mn) {
+    if (l > r) return 0;
+    if (l == r) return k * (node[l][1] < mn) + node[l][2];
+    if (dp[l][r].count(mn)) return dp[l][r][mn];
+    int ans = INT_MAX;
+    for (int i = l; i <= r; i++) {
+        ans = min(ans, solve(l, i - 1, mn) + solve(i + 1, r, mn) + k);
+        if (node[i][1] >= mn)
+            ans = min(ans, solve(l, i - 1, node[i][1]) + solve(i + 1, r, node[i][1]));
+    }
+    return dp[l][r][mn] = ans + pref[r] - pref[l - 1];
+}
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    cin >> n >> k;
+    for (int i : {0, 1, 2})
+        for (int j = 1; j <= n; j++) cin >> node[j][i];
+    sort(node + 1, node + n + 1);
+    for (int i = 1; i <= n; i++) pref[i] = pref[i - 1] + node[i][2];
+    cout << solve(1, n, 0);
+    return 0;
+}

NOI.cn/NOI 10-superpiano.cpp

@@ -0,0 +1,86 @@
+/*
+NOI.cn 2010 Super Piano
+- First, build a prefix sum array of the note values
+- The best chord we can make starting on note i has value
+    max(pref[j] : j from i + l to i + r) - pref[i - 1]
+- This is a range query, so we can use a segment tree to
+  handle it and remove that optimal position after using it
+- However, there can be multiple different starting notes,
+  so we can't just straight-up remove values from the segtree,
+  since other starting positions could potentially depend on
+  those
+- To address this, simply use a persistent segtree so that
+  each starting position has its own segtree
+- There are O(K + N) nodes because we update K times
+- Complexity: O((K + N) log N)
+*/
+
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+struct Node {
+    pair<int, int> val;
+    Node *lc, *rc;
+
+    Node(pair<int, int> _val) : val(_val), lc(nullptr), rc(nullptr) {}
+
+    Node(Node *_lc, Node *_rc) : lc(_lc), rc(_rc), val({INT_MIN, -1}) {
+        if (lc) val = max(val, lc->val);
+        if (rc) val = max(val, rc->val);
+    }
+} * persist_roots[500001];
+
+int n, x, y, k, pref[500001];
+
+Node *build(int l = 1, int r = n) {
+    if (l == r) return new Node({pref[l], l});
+    int mid = (l + r) / 2;
+    return new Node(build(l, mid), build(mid + 1, r));
+}
+
+pair<int, int> query(Node *node, int a, int b, int l = 1, int r = n) {
+    if (!node || r < a || l > b) return {INT_MIN, -1};
+    if (l >= a && r <= b) return node->val;
+    int mid = (l + r) / 2;
+    return max(query(node->lc, a, b, l, mid),
+               query(node->rc, a, b, mid + 1, r));
+}
+
+Node *update(Node *node, int pos, int l = 1, int r = n) {
+    if (l == r) return nullptr;
+    int mid = (l + r) / 2;
+    if (pos > mid) return new Node(node->lc, update(node->rc, pos, mid + 1, r));
+    return new Node(update(node->lc, pos, l, mid), node->rc);
+}
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    cin >> n >> k >> x >> y;
+    for (int i = 1; i <= n; i++) {
+        int a;
+        cin >> a;
+        pref[i] = pref[i - 1] + a;
+    }
+    Node *init_root = build();
+    for (int i = 1; i <= n - x + 1; i++) persist_roots[i] = init_root;
+
+    priority_queue<pair<int, int>> pq;
+    for (int i = 1; i <= n - x + 1; i++) {
+        pair<int, int> res = query(persist_roots[i], i + x - 1, i + y - 1);
+        pq.push({res.first - pref[i - 1], i});
+        persist_roots[i] = update(persist_roots[i], res.second);
+    }
+    ll ans = 0;
+    while (k--) {
+        int v, i;
+        tie(v, i) = pq.top();
+        pq.pop();
+        ans += v;
+        pair<int, int> res = query(persist_roots[i], i + x - 1, i + y - 1);
+        pq.push({res.first - pref[i - 1], i});
+        persist_roots[i] = update(persist_roots[i], res.second);
+    }
+    cout << ans;
+    return 0;
+}