abc424

Author: fei0319

code/atcoder/abc424_a.cpp

@@ -0,0 +1,19 @@
+#include <bits/stdc++.h>
+
+void solve() {
+    int a, b, c;
+    std::cin >> a >> b >> c;
+
+    if (a == b || b == c || a == c) {
+        std::cout << "Yes\n";
+    } else {
+        std::cout << "No\n";
+    }
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    solve();
+}

code/atcoder/abc424_b.cpp

@@ -0,0 +1,23 @@
+#include <bits/stdc++.h>
+
+void solve() {
+    int n, m, k;
+    std::cin >> n >> m >> k;
+
+    std::vector<int> cnt(n + 1);
+    while (k--) {
+        int a, b;
+        std::cin >> a >> b;
+        cnt[a] += 1;
+        if (cnt[a] == m) {
+            std::cout << a << " ";
+        }
+    }
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    solve();
+}

code/atcoder/abc424_c.cpp

@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+
+void solve() {
+    int n;
+    std::cin >> n;
+
+    std::vector<uint8_t> vis(n + 1);
+    std::vector<int> layer;
+
+    std::vector<std::vector<int>> adj(n + 1);
+    for (int i = 1; i <= n; ++i) {
+        int a, b;
+        std::cin >> a >> b;
+
+        if (a == 0) {
+            vis[i] = true;
+            layer.push_back(i);
+        } else {
+            adj[a].push_back(i);
+            adj[b].push_back(i);
+        }
+    }
+
+    while (!layer.empty()) {
+        std::vector<int> next_layer;
+        for (int x : layer) {
+            for (int to : adj[x]) {
+                if (!vis[to]) {
+                    vis[to] = true;
+                    next_layer.push_back(to);
+                }
+            }
+        }
+        std::swap(layer, next_layer);
+    }
+
+    std::cout << std::count(vis.begin(), vis.end(), true) << '\n';
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    solve();
+}

code/atcoder/abc424_d.cpp

@@ -0,0 +1,57 @@
+#include <bits/stdc++.h>
+
+void solve() {
+    int h, w;
+    std::cin >> h >> w;
+
+    std::vector<int> a(h);
+    for (int i = 0; i < h; ++i) {
+        std::string str;
+        std::cin >> str;
+        for (int j = 0; j < w; ++j) {
+            if (str[j] == '#') {
+                a[i] |= 1 << j;
+            }
+        }
+    }
+
+    std::vector<int> dp(1 << w);
+    for (int S = 0; S < (1 << w); ++S) {
+        dp[S] = __builtin_popcount(S ^ a[0]);
+    }
+
+    auto check = [w](int S, int T) -> bool {
+        for (int i = 0; i + 1 < w; ++i) {
+            if (((S >> i) & 3) == 3 && ((T >> i) & 3) == 3) {
+                return false;
+            }
+        }
+        return true;
+    };
+
+    for (int i = 1; i < h; ++i) {
+        std::vector<int> next_dp(1 << w);
+        for (int S = 0; S < (1 << w); ++S) {
+            int min = dp[0];
+            for (int T = 0; T < (1 << w); ++T) {
+                if (dp[T] < min && check(S, T)) {
+                    min = dp[T];
+                }
+            }
+            next_dp[S] = min + __builtin_popcount(S ^ a[i]);
+        }
+        dp = std::move(next_dp);
+    }
+
+    std::cout << std::ranges::min(dp) << '\n';
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    int t;
+    std::cin >> t;
+
+    while (t--) solve();
+}

code/atcoder/abc424_e.cpp

@@ -0,0 +1,47 @@
+#include <bits/stdc++.h>
+
+using fp = long double;
+using i64 = int64_t;
+
+void solve() {
+    int n, k, x;
+    std::cin >> n >> k >> x;
+
+    std::vector<int> a(n);
+    for (int &i : a) std::cin >> i;
+
+    auto check = [&](fp v) -> bool {
+        i64 c = 0;
+        int g = 0;
+        for (int i : a) {
+            if (i >= v) {
+                c += (1LL << (63 - __builtin_clzll(i / v)));
+                g += 1;
+            }
+        }
+
+        if (k <= c - g) return g + k >= x;
+        return c - (k - (c - g)) >= x;
+    };
+
+    fp l = 0, r = std::ranges::max(a);
+    while (r - l > 1e-10) {
+        fp mid = (l + r) / 2;
+        if (check(mid)) l = mid;
+        else r = mid;
+    }
+
+    std::cout << l << '\n';
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    std::cout << std::fixed << std::setprecision(12);
+
+    int t;
+    std::cin >> t;
+
+    while (t--) solve();
+}

code/atcoder/abc424_f.cpp

@@ -0,0 +1,45 @@
+#include <bits/stdc++.h>
+
+using u64 = uint64_t;
+std::mt19937_64 rng(std::random_device{}());
+
+void solve() {
+    int n, q;
+    std::cin >> n >> q;
+
+    std::vector<u64> tr(n + 1);
+    auto update = [&](int x, u64 k) {
+        for (; x <= n; x += x & -x) tr[x] ^= k;
+    };
+    auto query = [&](int x) {
+        u64 res = 0;
+        for (; x; x -= x & -x) res ^= tr[x];
+        return res;
+    };
+
+    while (q--) {
+        int a, b;
+        std::cin >> a >> b;
+
+        if (a > b) {
+            std::swap(a, b);
+        }
+
+        if (query(a) != query(b)) {
+            std::cout << "No\n";
+            continue;
+        }
+
+        std::cout << "Yes\n";
+        const u64 h = rng();
+        update(a, h);
+        update(b, h);
+    }
+}
+
+int main() {
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    solve();
+}