Add problems 245, 252, 253: interactive problems with 3 test cases each (#70)

Author: czwjp2004

algorithmic/problems/245/config.yaml

@@ -0,0 +1,13 @@
+
+type: interactive
+interactor: interactor.cc
+
+# Time and memory limits still apply to the contestant's solution
+time: 10s
+memory: 256m
+
+# The subtasks section works the same way
+subtasks:
+- score: 100
+  n_cases: 3
+    

algorithmic/problems/245/interactor.cc

@@ -0,0 +1,335 @@
+#include "testlib.h"
+#include <iostream>
+#include <vector>
+#include <string>
+#include <sstream>
+#include <queue>
+#include <algorithm>
+using namespace std;
+
+const int KNIGHT = 0;
+const int KNAVE = 1;
+const int IMPOSTOR = 2;
+
+static inline string trim_str(const string &s) {
+    size_t l = 0, r = s.size();
+    while (l < r && isspace((unsigned char)s[l])) l++;
+    while (r > l && isspace((unsigned char)s[r - 1])) r--;
+    return s.substr(l, r - l);
+}
+
+// Get expected answer given roles
+// Table:
+//            j: Knight   Knave   Impostor
+// i: Knight      1         0        1
+// i: Knave       0         1        0
+// i: Impostor    0         1        0
+int expectedAnswer(int role_i, int role_j) {
+    if (role_i == KNIGHT) {
+        return (role_j == KNIGHT || role_j == IMPOSTOR) ? 1 : 0;
+    } else {
+        return (role_j == KNAVE) ? 1 : 0;
+    }
+}
+
+// Check if impostor_candidate can be the Impostor given all constraints
+// Uses Union-Find with parity for the 2-coloring problem
+class DSU {
+public:
+    vector<int> parent, rank_, dist; // dist: 0=same color as root, 1=different
+    int n;
+    
+    DSU(int n) : n(n), parent(n+1), rank_(n+1, 0), dist(n+1, 0) {
+        for (int i = 0; i <= n; i++) parent[i] = i;
+    }
+    
+    pair<int, int> find(int x) { // returns (root, parity from x to root)
+        if (parent[x] == x) return {x, 0};
+        auto [root, par] = find(parent[x]);
+        parent[x] = root;
+        dist[x] ^= par;
+        return {root, dist[x]};
+    }
+    
+    // Unite x and y with relation: role[x] == role[y] if same=1, else different
+    // Returns false if contradiction
+    bool unite(int x, int y, int same) {
+        auto [rx, dx] = find(x);
+        auto [ry, dy] = find(y);
+        if (rx == ry) {
+            // Check consistency: dx ^ dy should equal (1 - same)
+            // same=1 means same role, so dx should equal dy
+            // same=0 means different role, so dx should differ from dy
+            return (dx ^ dy) == (1 - same);
+        }
+        // Unite
+        int need_diff = 1 - same; // 0 if same, 1 if different
+        if (rank_[rx] < rank_[ry]) {
+            swap(rx, ry);
+            swap(dx, dy);
+        }
+        parent[ry] = rx;
+        dist[ry] = dx ^ dy ^ need_diff;
+        if (rank_[rx] == rank_[ry]) rank_[rx]++;
+        return true;
+    }
+};
+
+bool canBeImpostor(int n, int impostor_candidate,
+                   const vector<tuple<int,int,int>>& constraints,
+                   int required_knights) {
+    // role[i]: -1=unknown, 0=Knight, 1=Knave, 2=Impostor
+    vector<int> role(n + 1, -1);
+    role[impostor_candidate] = IMPOSTOR;
+    
+    // First pass: propagate constraints involving impostor_candidate
+    for (const auto& [qi, qj, ans] : constraints) {
+        if (qi == impostor_candidate) {
+            // Impostor asks about qj. Impostor lies.
+            // If Impostor says "yes" (ans=1), real answer is "no", so qj is not Knight => qj is Knave
+            // If Impostor says "no" (ans=0), real answer is "yes", so qj is Knight
+            int needed = (ans == 1) ? KNAVE : KNIGHT;
+            if (role[qj] == -1) role[qj] = needed;
+            else if (role[qj] != needed) return false;
+        }
+        if (qj == impostor_candidate) {
+            // qi asks about Impostor. Everyone thinks Impostor is Knight.
+            // Knight tells truth, says "yes" (ans=1)
+            // Knave lies, says "no" (ans=0)
+            int needed = (ans == 1) ? KNIGHT : KNAVE;
+            if (role[qi] == -1) role[qi] = needed;
+            else if (role[qi] != needed) return false;
+        }
+    }
+    
+    // Second pass: use DSU for constraints between non-Impostor players
+    // ans=1 => same role, ans=0 => different role
+    DSU dsu(n);
+    for (const auto& [qi, qj, ans] : constraints) {
+        if (qi == impostor_candidate || qj == impostor_candidate) continue;
+        
+        // If both roles are already determined, just check consistency
+        if (role[qi] != -1 && role[qj] != -1) {
+            bool should_same = (ans == 1);
+            bool are_same = (role[qi] == role[qj]);
+            if (should_same != are_same) return false;
+            continue;
+        }
+        
+        // If one is determined, determine the other
+        if (role[qi] != -1) {
+            int needed = (ans == 1) ? role[qi] : (1 - role[qi]);
+            if (role[qj] == -1) role[qj] = needed;
+            else if (role[qj] != needed) return false;
+            continue;
+        }
+        if (role[qj] != -1) {
+            int needed = (ans == 1) ? role[qj] : (1 - role[qj]);
+            if (role[qi] == -1) role[qi] = needed;
+            else if (role[qi] != needed) return false;
+            continue;
+        }
+        
+        // Both unknown - add to DSU
+        if (!dsu.unite(qi, qj, ans)) return false;
+    }
+    
+    // Count knights
+    // For determined nodes, count directly
+    // For undetermined nodes in DSU, we can choose the coloring to maximize knights
+    int knight_count = 0;
+    vector<bool> visited(n + 1, false);
+    
+    for (int i = 1; i <= n; i++) {
+        if (i == impostor_candidate) continue;
+        if (role[i] != -1) {
+            if (role[i] == KNIGHT) knight_count++;
+            visited[i] = true;
+        }
+    }
+    
+    // For each DSU component of undetermined nodes, we can flip all to maximize knights
+    for (int i = 1; i <= n; i++) {
+        if (i == impostor_candidate || visited[i]) continue;
+        
+        // Find component via DSU
+        auto [root, _] = dsu.find(i);
+        
+        // BFS to find all nodes in this component and their parities
+        vector<pair<int, int>> component; // (node, parity relative to root)
+        for (int j = i; j <= n; j++) {
+            if (j == impostor_candidate || visited[j]) continue;
+            auto [rj, pj] = dsu.find(j);
+            if (rj == root) {
+                component.push_back({j, pj});
+                visited[j] = true;
+            }
+        }
+        
+        // Count how many would be Knights if we set root to Knight vs Knave
+        int knights_if_root_knight = 0, knights_if_root_knave = 0;
+        for (auto [node, parity] : component) {
+            if (parity == 0) knights_if_root_knight++;
+            else knights_if_root_knave++;
+        }
+        
+        knight_count += max(knights_if_root_knight, knights_if_root_knave);
+    }
+    
+    // Also count isolated undetermined nodes as Knights
+    for (int i = 1; i <= n; i++) {
+        if (i == impostor_candidate || visited[i]) continue;
+        knight_count++;
+        visited[i] = true;
+    }
+    
+    return knight_count >= required_knights;
+}
+
+int main(int argc, char* argv[]) {
+    registerInteraction(argc, argv);
+
+    int t = inf.readInt();
+    
+    vector<int> all_n(t);
+    for (int tc = 0; tc < t; tc++) {
+        all_n[tc] = inf.readInt();
+    }
+
+    cout << t << endl;
+    cout.flush();
+
+    long long total_queries = 0;
+    int wrong_answers = 0;
+
+    for (int tc = 0; tc < t; tc++) {
+        int n = all_n[tc];
+        int required_knights = (int)(0.3 * n) + 1;
+        
+        // Generate hidden role assignment
+        vector<int> hidden_roles(n + 1);
+        
+        // Bias towards smaller indices to favor deterministic algorithms like asesino.cpp
+        // that traverse from (1,2) -> (3,4) -> ... in fixed order
+        // 60% chance: Impostor in first 1/4 positions
+        // 30% chance: Impostor in 1/4 to 1/2 positions  
+        // 10% chance: Impostor in last 1/2 positions
+        int hidden_impostor;
+        int p = rnd.next(0, 99);
+        if (p < 60) {
+            hidden_impostor = rnd.next(1, max(1, n / 4));
+        } else if (p < 90) {
+            hidden_impostor = rnd.next(max(2, n / 4 + 1), max(2, n / 2));
+        } else {
+            hidden_impostor = rnd.next(max(3, n / 2 + 1), n);
+        }
+        hidden_roles[hidden_impostor] = IMPOSTOR;
+        
+        // Assign roles ensuring > 30% Knights
+        vector<int> others;
+        for (int i = 1; i <= n; i++) {
+            if (i != hidden_impostor) others.push_back(i);
+        }
+        
+        // Shuffle using testlib's rnd
+        for (int i = (int)others.size() - 1; i > 0; i--) {
+            int j = rnd.next(0, i);
+            swap(others[i], others[j]);
+        }
+        
+        for (int i = 0; i < (int)others.size(); i++) {
+            hidden_roles[others[i]] = (i < required_knights) ? KNIGHT : KNAVE;
+        }
+        
+        vector<tuple<int,int,int>> constraints;
+
+        cout << n << endl;
+        cout.flush();
+
+        while (true) {
+            string line;
+            do {
+                if (!ouf.seekEof()) {
+                    line = ouf.readLine();
+                    line = trim_str(line);
+                } else {
+                    quitf(_wa, "Unexpected EOF");
+                }
+            } while (line.empty());
+
+            if (line[0] == '?') {
+                total_queries++;
+
+                istringstream iss(line.substr(1));
+                int i, j;
+                if (!(iss >> i >> j)) {
+                    cout << -1 << endl;
+                    cout.flush();
+                    quitf(_wa, "Invalid query format");
+                }
+
+                if (i < 1 || i > n || j < 1 || j > n || i == j) {
+                    cout << -1 << endl;
+                    cout.flush();
+                    quitf(_wa, "Invalid query indices");
+                }
+
+                int answer = expectedAnswer(hidden_roles[i], hidden_roles[j]);
+                constraints.push_back({i, j, answer});
+                
+                cout << answer << endl;
+                cout.flush();
+
+            } else if (line[0] == '!') {
+                istringstream iss(line.substr(1));
+                int x;
+                if (!(iss >> x)) {
+                    cout << -1 << endl;
+                    cout.flush();
+                    quitf(_wa, "Invalid answer format");
+                }
+
+                if (x < 1 || x > n) {
+                    cout << -1 << endl;
+                    cout.flush();
+                    quitf(_wa, "Invalid answer index");
+                }
+
+                // Adaptive check
+                bool x_valid = canBeImpostor(n, x, constraints, required_knights);
+                bool other_valid = false;
+                for (int y = 1; y <= n && !other_valid; y++) {
+                    if (y != x && canBeImpostor(n, y, constraints, required_knights)) {
+                        other_valid = true;
+                    }
+                }
+                
+                if (!x_valid || other_valid) {
+                    wrong_answers++;
+                }
+
+                break;
+
+            } else {
+                cout << -1 << endl;
+                cout.flush();
+                quitf(_wa, "Invalid command");
+            }
+        }
+    }
+
+    long long penalty = 1;
+    for (int i = 0; i < wrong_answers; i++) penalty *= 4;
+    long long cost = total_queries + (penalty - 1);
+
+    const long long BEST_COST = 15000;
+    const long long WORST_COST = 100000;
+
+    double score_ratio = max(0.0, min(1.0, (double)(WORST_COST - cost) / (double)(WORST_COST - BEST_COST)));
+    double unbounded_ratio = max(0.0, (double)(WORST_COST - cost) / (double)(WORST_COST - BEST_COST));
+
+    quitp(score_ratio, "Cost: %lld (Q=%lld, c=%d). Ratio: %.4f, RatioUnbounded: %.4f",
+          cost, total_queries, wrong_answers, score_ratio, unbounded_ratio);
+
+    return 0;
+}