File size: 8,404 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 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 |
// The Big Prize interactor (stdout version; 0-based indices; Testlib)
// Time limit and memory limit are enforced by the judge runner, not here.
//
// Build example (Linux):
// g++ -std=gnu++17 -O2 -pipe -static -s -o interactor interactor.cpp
//
// Run example (with testlib):
// ./interactor --inf=instance.txt --ans=best.txt -- -team-command-
//
// Hidden instance file (inf):
// n
// t0 t1 ... t{n-1}
//
// Answer file (.ans):
// optimal_queries
//
// Protocol to participant (stdout/stdin):
// - Interactor prints: n
// - For each query, participant prints: "? i" (0 <= i < n), then flushes
// Interactor replies: "a0 a1"
// - When done, participant prints: "! i" (diamond index), then exits.
//
// Scoring: your_score = max(0, 5000 - q)
// best_score = max(0, 5000 - optimal_queries)
// ratio = your_score / best_score (with special-casing best_score == 0)
#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;
}
// Simple Fenwick (1-indexed)
struct Fenwick {
int n; vector<int> f;
Fenwick(int n = 0): n(n), f(n + 1, 0) {}
void add(int i, int v) { for (; i <= n; i += i & -i) f[i] += v; }
int sum(int i) const { int s = 0; for (; i > 0; i -= i & -i) s += f[i]; return s; }
};
int main(int argc, char* argv[]) {
setName("The Big Prize interactor (stdout version; 0-based; ratio scoring)");
registerInteraction(argc, argv);
// ---- Problem constraints ----
const int N_MIN = 3;
const int N_MAX = 200000;
const int SCORE_BASE = 5000; // scoring: 5000 - queries
const int QUERY_LIMIT = 1000000; // generous hard cap to prevent infinite loops
// ---- Read hidden instance from 'inf': n and types t[0..n-1] ----
int n = inf.readInt(N_MIN, N_MAX, "n");
vector<int> t(n);
for (int i = 0; i < n; ++i) {
t[i] = inf.readInt(1, 1000000000, format("t[%d]", i).c_str());
}
// ---- Validate instance constraints ----
int v = 0;
for (int x : t) v = max(v, x);
// there is exactly one diamond (type 1)
int cnt_type1 = 0;
for (int x : t) if (x == 1) ++cnt_type1;
ensuref(cnt_type1 == 1, "Invalid instance: expected exactly one type-1 (diamond), got %d.", cnt_type1);
// count per type
vector<long long> cnt(v + 1, 0);
for (int x : t) cnt[x]++;
// growth rule: for all 2..v, cnt[t] > (cnt[t-1])^2
for (int typ = 2; typ <= v; ++typ) {
long long prev = cnt[typ - 1];
long long need = prev * prev; // may be large; compare with long long
ensuref(cnt[typ] > need,
"Invalid instance: count[type=%d]=%lld is not strictly greater than (count[type=%d])^2=%lld.",
typ, cnt[typ], typ - 1, need);
}
// ---- Precompute answers (a0, a1) for all positions using Fenwick ----
// Compress types to ranks 1..V in increasing order of "type number" (1 is smallest)
vector<int> comp = t;
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end()); // size == v
// Map type -> rank (1..v) preserving order
auto getRank = [&](int x) {
// lower_bound finds index where comp[idx] == x
int idx = int(lower_bound(comp.begin(), comp.end(), x) - comp.begin()) + 1; // 1-based
return idx;
};
const int V = (int)comp.size();
vector<int> rankv(n);
for (int i = 0; i < n; ++i) rankv[i] = getRank(t[i]);
vector<int> a0(n, 0), a1(n, 0);
// a0[i] = number of more-expensive prizes to the LEFT of i
// "More expensive" => smaller type number => smaller rank
{
Fenwick fw(V);
for (int i = 0; i < n; ++i) {
int r = rankv[i];
a0[i] = fw.sum(r - 1);
fw.add(r, 1);
}
}
// a1[i] = number of more-expensive prizes to the RIGHT of i
{
Fenwick fw(V);
for (int i = n - 1; i >= 0; --i) {
int r = rankv[i];
a1[i] = fw.sum(r - 1);
fw.add(r, 1);
}
}
// ---- Diamond index (type 1) ----
int diamondIndex = -1;
for (int i = 0; i < n; ++i) if (t[i] == 1) { diamondIndex = i; break; }
ensuref(diamondIndex != -1, "Internal error: diamond index not found.");
// ---- 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;
int queries = 0; // number of answered '?' queries
auto finalize_with_ratio = [&](double ratio, double unbounded_ratio, const string &fmt, auto... args) {
string base = format(fmt.c_str(), args...);
quitp(ratio, "%s Ratio: %.6f, RatioUnbounded: %.6f", base.c_str(), ratio, unbounded_ratio);
};
while (true) {
// Expect either "?" or "!" from the participant
string cmd = ouf.readToken();
if (cmd == "?") {
// Read token for i and validate manually (in-bounds check)
string si = ouf.readToken();
int i = 0;
bool okI = parse_int32(si, i);
if (!okI) {
// Return an explicit invalid response to avoid hanging the participant
cout << -1 << ' ' << -1 << '\n' << flush;
quitf(_pe, "Invalid query: expected integer index for i, got '%s'.",
compress(si).c_str());
}
if (i < 0 || i >= n) {
cout << -1 << ' ' << -1 << '\n' << flush;
quitf(_wa, "Query out of bounds: i=%d (valid range is [0,%d]).", i, n - 1);
}
if (queries > QUERY_LIMIT) {
cout << -1 << ' ' << -1 << '\n' << flush;
finalize_with_ratio(0.0, 0.0, "Query limit exceeded: %d > %d.", queries, QUERY_LIMIT);
}
// Answer: a0[i] a1[i]
cout << a0[i] << ' ' << a1[i] << '\n' << flush;
++queries;
}
else if (cmd == "!") {
// Read final answer: exactly one integer index in [0..n-1]
int gi = ouf.readInt(0, n - 1, "answer_index");
if (gi != diamondIndex) {
// Wrong answer -> ratio 0.0
finalize_with_ratio(0.0, 0.0,
"Wrong answer: reported index %d, diamond is at %d. Queries used: %d.",
gi, diamondIndex, queries);
}
// ---- Compute scores and ratio ----
int your_raw_nonneg = max(0, SCORE_BASE - queries);
int best_raw_nonneg = max(0, SCORE_BASE - optimal_queries);
double your_score = (double)your_raw_nonneg;
double best_score = (double)best_raw_nonneg;
double ratio;
double unbounded_ratio;
if (best_score <= 0.0) {
ratio = (your_score <= 0.0) ? 1.0 : 0.0;
unbounded_ratio = ratio;
} else {
ratio = your_score / best_score;
if (ratio < 0.0) ratio = 0.0;
unbounded_ratio = ratio;
if (ratio > 1.0) ratio = 1.0;
}
finalize_with_ratio(ratio, unbounded_ratio,
"Accepted. Queries used: %d. Your score = 5000 - %d = %d. "
"Optimal queries: %d. Best score = 5000 - %d = %d.",
queries, queries, your_raw_nonneg,
optimal_queries, optimal_queries, best_raw_nonneg);
}
else {
// Unexpected token
cout << -1 << ' ' << -1 << '\n' << flush;
quitf(_pe, "Expected '?' or '!' but got '%s'.", compress(cmd).c_str());
}
}
}
|