USACO 2021 + CSES problems

dolphingarlic · dolphingarlic · commit 98ecb17129d3 · 2021-01-28T21:04:01.000+02:00
diff --git a/CSES/(10) Additional Problems/2179.cpp b/CSES/(10) Additional Problems/2179.cpp
@@ -0,0 +1,41 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<int> graph[100001];
+int visited[100001], odd[100001], timer = 1;
+vector<pair<int, int>> ans;
+
+void dfs(int node, int parent = 0) {
+    visited[node] = timer++;
+    for (int i : graph[node]) if (i != parent) {
+        if (!visited[i]) {
+            dfs(i, node);
+            if (odd[i]) {
+                ans.push_back({i, node});
+                odd[i] = 0;
+            } else {
+                ans.push_back({node, i});
+                odd[node] ^= 1;
+            }
+        } else if (visited[node] > visited[i]) {
+            ans.push_back({node, i});
+            odd[node] ^= 1;
+        }
+    }
+}
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    int n, m;
+    scanf("%d %d", &n, &m);
+    while (m--) {
+        int u, v;
+        scanf("%d %d", &u, &v);
+        graph[u].push_back(v);
+        graph[v].push_back(u);
+    }
+    for (int i = 1; i <= n; i++) if (!visited[i]) dfs(i);
+    if (accumulate(odd + 1, odd + n + 1, 0)) printf("IMPOSSIBLE");
+    else for (pair<int, int> i : ans) printf("%d %d\n", i.first, i.second);
+    return 0;
+}
diff --git a/CSES/(7) Mathematics/2185.cpp b/CSES/(7) Mathematics/2185.cpp
@@ -0,0 +1,22 @@
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+ll a[20];
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    ll n;
+    int k;
+    cin >> n >> k;
+    for (int i = 0; i < k; i++) cin >> a[i];
+    ll ans = 0;
+    for (int mask = 1; mask < (1 << k); mask++) {
+        int mult = 1 - 2 * (__builtin_popcount(mask) & 1);
+        ll tmp = n;
+        for (int i = 0; i < k; i++) if (mask & (1 << i)) tmp /= a[i];
+        ans += mult * tmp;
+    }
+    cout << abs(ans);
+    return 0;
+}
diff --git a/USACO/USACO 21-paint.cpp b/USACO/USACO 21-paint.cpp
@@ -0,0 +1,101 @@
+/*
+USACO 2021 Paint by Letters
+- http://usaco.org/current/data/sol_prob3_platinum_jan21.html
+- Very cool problem; whoever made it deserves a medal ;)
+- Complexity: O(NM + Q(N + M))
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+int n, m, q;
+char grid[2001][2001];
+pair<int, int> cmp[2002][2002], d[4]{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
+int s_pref[2002][2002], v_pref[2002][2002], h_pref[2002][2002];
+bool deleted[2002][2002];
+
+bool inside(int x, int y, int nx, int ny) {
+    if (!(~nx && ~ny && nx <= n + 1 && ny <= m + 1)) return false;
+    if (nx == x + 1) return grid[x][y] != grid[x][y - 1];
+    if (nx == x - 1) return grid[nx][y] != grid[nx][y - 1];
+    if (ny == y + 1) return grid[x][y] != grid[x - 1][y];
+    return grid[x][ny] != grid[x - 1][ny];
+}
+
+void dfs(int x, int y) {
+    for (int i = 0; i < 4; i++) {
+        int nx = x + d[i].first, ny = y + d[i].second;
+        if (inside(x, y, nx, ny)) {
+            if (nx == x + 1) v_pref[x][y] = 1;
+            else if (nx == x - 1) v_pref[nx][y] = 1;
+            else if (ny == y + 1) h_pref[x][y] = 1;
+            else h_pref[x][ny] = 1;
+
+            if (!cmp[nx][ny].first) {
+                cmp[nx][ny] = cmp[x][y];
+                dfs(nx, ny);
+            }
+        }
+    }
+}
+
+bool bad(int x, int y, int x1, int y1, int x2, int y2) {
+    int a = cmp[x][y].first, b = cmp[x][y].second;
+    if (a > x1 && a <= x2 && b > y1 && b <= y2 && !deleted[a][b]) {
+        deleted[a][b] = true;
+        return true;
+    }
+    return false;
+}
+
+void reset(int x, int y) {
+    int a = cmp[x][y].first, b = cmp[x][y].second;
+    deleted[a][b] = false;
+}
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    cin >> n >> m >> q;
+    for (int i = 1; i <= n; i++)
+        for (int j = 1; j <= m; j++)
+            cin >> grid[i][j];
+    for (int i = 1; i <= n + 1; i++)
+        for (int j = 1; j <= m + 1; j++)
+            if (!cmp[i][j].first) {
+                s_pref[i][j] = 1;
+                cmp[i][j] = {i, j};
+                dfs(i, j);
+            }
+    for (int i = 1; i <= n + 1; i++)
+        for (int j = 1; j <= m + 1; j++) {
+            s_pref[i][j] += s_pref[i - 1][j] + s_pref[i][j - 1] - s_pref[i - 1][j - 1];
+            v_pref[i][j] += v_pref[i - 1][j] + v_pref[i][j - 1] - v_pref[i - 1][j - 1];
+            h_pref[i][j] += h_pref[i - 1][j] + h_pref[i][j - 1] - h_pref[i - 1][j - 1];
+        }
+    while (q--) {
+        int x1, x2, y1, y2;
+        cin >> x1 >> y1 >> x2 >> y2;
+        int E = v_pref[x2][y2] - v_pref[x2][y1] - v_pref[x1 - 1][y2] + v_pref[x1 - 1][y1] +
+                h_pref[x2][y2] - h_pref[x2][y1 - 1] - h_pref[x1][y2] + h_pref[x1][y1 - 1];
+        int V = (x2 - x1) * (y2 - y1);
+        int C = s_pref[x2][y2] - s_pref[x2][y1] - s_pref[x1][y2] + s_pref[x1][y1];
+        for (int i = x1; i <= x2 + 1; i++) {
+            if (bad(i, y2 + 1, x1, y1, x2, y2)) C--;
+            if (bad(i, y1, x1, y1, x2, y2)) C--;
+        }
+        for (int i = y1; i <= y2 + 1; i++) {
+            if (bad(x2 + 1, i, x1, y1, x2, y2)) C--;
+            if (bad(x1, i, x1, y1, x2, y2)) C--;
+        }
+        for (int i = x1; i <= x2 + 1; i++) {
+            reset(i, y2 + 1);
+            reset(i, y1);
+        }
+        for (int i = y1; i <= y2 + 1; i++) {
+            reset(x2 + 1, i);
+            reset(x1, i);
+        }
+        cout << E - V + C + 1 << '\n';
+    }
+    return 0;
+}
diff --git a/USACO/USACO 21-sumdist.cpp b/USACO/USACO 21-sumdist.cpp
@@ -0,0 +1,114 @@
+/*
+USACO 2021 Sum of Distances
+- The distance to a K-tuple (v[1], v[2], ..., v[K]) from (1, 1, ..., 1) is
+    min(max(1 -> v[i] where the path is even), max(1 -> v[i] where the path is odd))
+- We can use a segtree/BIT + DP to compute sum(max(1 -> v[i] where the path is even) for each tuple)
+    - First, sort the graphs by size
+    - Let dp[i][j] be the number of i-tuples (i.e. from the first i graphs) with *even* distance j
+    - First, compute dp[i][j] = sum(dp[i - 1][l] where l <= j)
+    - Next, update dp[i][j] = (No. of even paths from node 1 in graph i of length < j) * dp[i - 1][j]
+    - dp[K][j] will be the number of K-tuples with *even* distance j, so we can just iterate through dp[K]
+- Similar logic holds for the odd-distance tuples
+- What if a tuple can be reached in both even *and* odd distance though?
+    - If that happens, then we overcount the path with length max(even[i], odd[i] for each i), so just do
+      the above DP again but with maximums instead of evens/odds, and subtract that value from our answer
+    - This is kinda like PIE
+- Complexity: O(sum(N) log sum(N))
+*/
+
+#include <bits/stdc++.h>
+typedef long long ll;
+using namespace std;
+
+const ll MOD = 1e9 + 7;
+
+int k, n[50001], order[50001];
+vector<ll> segtree[50001];
+
+ll query(int a, int b, int tree, int node, int l, int r) {
+    if (l > b || r < a) return 0;
+    if (l >= a && r <= b) return segtree[tree][node];
+    int mid = (l + r) / 2;
+    return (query(a, b, tree, node * 2, l, mid) + query(a, b, tree, node * 2 + 1, mid + 1, r)) % MOD;
+}
+
+void update(int pos, ll val, int tree, int node, int l, int r) {
+    if (l == r) segtree[tree][node] = (segtree[tree][node] + val) % MOD;
+    else {
+        int mid = (l + r) / 2;
+        if (pos > mid) update(pos, val, tree, node * 2 + 1, mid + 1, r);
+        else update(pos, val, tree, node * 2, l, mid);
+        segtree[tree][node] = (segtree[tree][node * 2] + segtree[tree][node * 2 + 1]) % MOD;
+    }
+}
+
+void reset(int tree) { segtree[tree].clear(); segtree[tree].resize(8 * n[tree]); }
+
+ll compute_sum(vector<pair<int, int>> dists) {
+    vector<vector<int>> graphs(k);
+    for (pair<int, int> i : dists) graphs[i.second].push_back(i.first);
+    
+    reset(order[0]);
+    for (int i : graphs[order[0]]) update(i, 1, order[0], 1, 0, 2 * n[order[0]] - 1);
+
+    for (int i = 1; i < k; i++) {
+        reset(order[i]);
+        vector<int> pref(2 * n[order[i]], 0);
+        for (int j : graphs[order[i]]) {
+            update(j, query(0, j, order[i - 1], 1, 0, 2 * n[order[i - 1]] - 1), order[i], 1, 0, 2 * n[order[i]] - 1);
+            pref[j]++;
+        }
+        for (int j = 1; j < 2 * n[order[i]]; j++) {
+            pref[j] += pref[j - 1];
+            update(j, pref[j - 1] * query(j, j, order[i - 1], 1, 0, 2 * n[order[i - 1]] - 1) % MOD, order[i], 1, 0, 2 * n[order[i]] - 1);
+        }
+    }
+
+    ll ans = 0;
+    for (int i = 1; i < 2 * n[order[k - 1]]; i++)
+        ans = (ans + query(i, 2 * n[order[k - 1]] - 1, order[k - 1], 1, 0, 2 * n[order[k - 1]] - 1)) % MOD;
+    return ans;
+}
+
+int main() {
+    cin.tie(0)->sync_with_stdio(0);
+    cin >> k;
+    vector<pair<int, int>> even, odd, mx;
+    for (int i = 0; i < k; i++) {
+        order[i] = i;
+        int m;
+        cin >> n[i] >> m;
+        vector<vector<int>> graph(2 * n[i]);
+        vector<int> visited(2 * n[i]);
+        while (m--) {
+            int u, v;
+            cin >> u >> v;
+            u--, v--;
+            graph[u].push_back(n[i] + v);
+            graph[v].push_back(n[i] + u);
+            graph[n[i] + u].push_back(v);
+            graph[n[i] + v].push_back(u);
+        }
+        // BFS to get even and odd distances
+        visited[0] = 1;
+        queue<int> q;
+        q.push(0);
+        while (q.size()) {
+            int curr = q.front();
+            q.pop();
+            for (int j : graph[curr]) if (!visited[j]) {
+                visited[j] = visited[curr] + 1;
+                q.push(j);
+            }
+        }
+        // Append to the distance lists
+        for (int j = 0; j < n[i]; j++) {
+            if (visited[j]) even.push_back({visited[j] - 1, i});
+            if (visited[n[i] + j]) odd.push_back({visited[n[i] + j] - 1, i});
+            if (visited[j] && visited[n[i] + j]) mx.push_back({max(visited[j], visited[n[i] + j]) - 1, i});
+        }
+    }
+    sort(order, order + k, [](int a, int b) { return n[a] < n[b]; });
+    cout << (compute_sum(even) + compute_sum(odd) - compute_sum(mx) + MOD) % MOD;
+    return 0;
+}
