File size: 6,768 Bytes
5fed0fc |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 |
#include "testlib.h"
#include <bits/stdc++.h>
using namespace std;
// ---------- helpers ----------
static inline bool parse_ll(const string& s, long long& x) {
if (s.empty()) return false;
size_t i = 0;
if (s[0] == '+' || s[0] == '-') i = 1;
if (i == s.size()) return false;
for (; i < s.size(); ++i) if (s[i] < '0' || s[i] > '9') return false;
try {
size_t pos = 0; long long v = stoll(s, &pos, 10);
if (pos != s.size()) return false; x = v; return true;
} catch (...) { return false; }
}
static inline bool parse_int32(const string& s, int& x) {
long long t; if (!parse_ll(s, t)) return false;
if (t < INT_MIN || t > INT_MAX) return false; x = (int)t; return true;
}
int main(int argc, char* argv[]) {
setName("Mineral Pairing interactor (stdout version; WA on violations; ratio on AC; queries allowed after first '!')");
registerInteraction(argc, argv);
// ---- Problem constraints ----
const int N_MIN = 1;
const int N_MAX = 43000;
const int QUERY_LIMIT = 1000000; // hard limit for answered '?' queries
// ---- Read hidden instance from 'inf' ----
int n = inf.readInt(N_MIN, N_MAX, "n");
const int m = 2 * n;
vector<int> kind(m + 1);
for (int x = 1; x <= m; ++x) {
kind[x] = inf.readInt(1, n, format("kind[%d]", x).c_str());
}
{
vector<int> cnt(n + 1, 0);
for (int x = 1; x <= m; ++x) ++cnt[kind[x]];
for (int k = 1; k <= n; ++k) {
ensuref(cnt[k] == 2, "Kind %d occurs %d times (expected exactly 2).", k, cnt[k]);
}
}
// ---- Read optimal #queries from '.ans' ----
int optimal_queries = ans.readInt(0, QUERY_LIMIT, "optimal_queries");
// ---- Public output: announce n and FLUSH ----
cout << n << '\n' << flush;
// ---- Device state ----
int queries = 0; // number of answered '?' queries
vector<char> present(m + 1, 0); // present[x] ? 1 : 0
vector<int> have(n + 1, 0); // how many slices of kind k are present (0..2)
int distinctKinds = 0; // # of kinds k with have[k] > 0
auto toggle = [&](int x) -> int {
int k = kind[x];
if (!present[x]) {
present[x] = 1;
if (have[k] == 0) ++distinctKinds;
++have[k];
} else {
present[x] = 0;
--have[k];
if (have[k] == 0) --distinctKinds;
}
return distinctKinds;
};
auto compute_ratio_unbounded = [&](int q_used, int q_opt) -> double {
long long denom = 1000000LL - (long long)q_opt;
long long numer = 1000000LL - (long long)q_used;
if (denom <= 0) return (q_used <= 1000000 ? 1.0 : 0.0);
double r = (double)numer / (double)denom;
if (r < 0.0) r = 0.0;
// if (r > 1.0) r = 1.0;
return r;
};
auto accept_with_ratio = [&](int q_used) {
double ratio_unbounded = compute_ratio_unbounded(q_used, optimal_queries);
double ratio = std::min(1.0, ratio_unbounded);
long long your_score = 1000000LL - (long long)q_used;
long long opt_score = 1000000LL - (long long)optimal_queries;
quitp(ratio,
"Accepted. Queries used: %d. Your score = 1000000 - %d = %lld. "
"Optimal queries: %d. Optimal score = 1000000 - %d = %lld. Ratio: %.4f, RatioUnbounded: %.4f",
q_used, q_used, your_score,
optimal_queries, optimal_queries, opt_score, ratio, ratio_unbounded);
};
// ---- Final answer tracking ----
vector<char> used(m + 1, 0);
int answered_pairs = 0;
try {
while (true) {
string cmd = ouf.readToken();
if (cmd == "?") {
string sx = ouf.readToken();
int x = 0;
if (!parse_int32(sx, x)) {
quitf(_pe, "Invalid query: expected integer for x, got '%s'.",
compress(sx).c_str());
}
if (x < 1 || x > m) {
quitf(_wa, "Query out of bounds: x=%d (valid range is [1,%d]).", x, m);
}
if (queries >= QUERY_LIMIT) {
quitf(_wa, "Too many queries: %d >= %d.", queries, QUERY_LIMIT);
}
int r = toggle(x);
cout << r << '\n' << flush;
++queries;
}
else if (cmd == "!") {
string sa = ouf.readToken();
string sb = ouf.readToken();
int a = 0, b = 0;
if (!parse_int32(sa, a) || !parse_int32(sb, b)) {
quitf(_pe, "Invalid answer line: expected integers for a and b, got '%s' and '%s'.",
compress(sa).c_str(), compress(sb).c_str());
}
if (a < 1 || a > m || b < 1 || b > m) {
quitf(_wa, "Answer out of bounds: a=%d, b=%d (valid range is [1,%d]).", a, b, m);
}
if (a == b) {
quitf(_wa, "Wrong Answer: pair has identical indices (%d,%d). Queries used: %d.",
a, b, queries);
}
if (used[a] || used[b]) {
quitf(_wa, "Wrong Answer: repeated slice index in answers "
"(a=%d used=%d, b=%d used=%d). Queries used: %d.",
a, (int)used[a], b, (int)used[b], queries);
}
if (kind[a] != kind[b]) {
quitf(_wa, "Wrong Answer: slices %d and %d are different kinds (%d != %d). "
"Queries used: %d.",
a, b, kind[a], kind[b], queries);
}
used[a] = used[b] = 1;
++answered_pairs;
if (answered_pairs == n) {
// Ensure every index covered exactly once
for (int x = 1; x <= m; ++x) {
if (!used[x]) {
quitf(_wa, "Wrong Answer: slice %d not covered by any pair. Queries used: %d.",
x, queries);
}
}
// Accepted only here
accept_with_ratio(queries);
}
}
else {
quitf(_pe, "Expected '?' or '!' but got '%s'.", compress(cmd).c_str());
}
}
} catch (const exception&) {
// If stream ended before giving n pairs, that's a WA by statement.
if (answered_pairs < n) {
quitf(_wa, "Wrong number of answers: expected %d pairs, got %d.", n, answered_pairs);
}
throw;
}
}
|