結果

問題 No.1306 Exactly 2 Digits
ユーザー kcvlex
提出日時 2020-12-04 22:34:22
言語 C++17
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 142 ms / 2,000 ms
コード長 6,978 bytes
コンパイル時間 2,246 ms
コンパイル使用メモリ 165,056 KB
最終ジャッジ日時 2025-01-16 16:10:51
ジャッジサーバーID
(参考情報)
judge5 / judge3
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 123
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#include <limits>
#include <initializer_list>
#include <utility>
#include <bitset>
#include <tuple>
#include <type_traits>
#include <functional>
#include <string>
#include <array>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <iterator>
#include <algorithm>
#include <complex>
#include <random>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <regex>
#include <cassert>
#include <cstddef>
#include <variant>
#define endl codeforces
#define ALL(v) std::begin(v), std::end(v)
#define ALLR(v) std::rbegin(v), std::rend(v)
using ll = std::int64_t;
using ull = std::uint64_t;
using pii = std::pair<int, int>;
using tii = std::tuple<int, int, int>;
using pll = std::pair<ll, ll>;
using tll = std::tuple<ll, ll, ll>;
using size_type = ssize_t;
template <typename T> using vec = std::vector<T>;
template <typename T> using vvec = vec<vec<T>>;
template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename T, typename... Tail> const T& var_min(const T &t, const Tail&... tail) { return std::min(t, var_min(tail...)); }
template <typename T, typename... Tail> const T& var_max(const T &t, const Tail&... tail) { return std::max(t, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }
template <typename T, std::size_t Head, std::size_t... Tail>
struct multi_dim_array { using type = std::array<typename multi_dim_array<T, Tail...>::type, Head>; };
template <typename T, std::size_t Head>
struct multi_dim_array<T, Head> { using type = std::array<T, Head>; };
template <typename T, std::size_t... Args> using mdarray = typename multi_dim_array<T, Args...>::type;
template <typename T, typename F, typename... Args>
void fill_seq(T &t, F f, Args... args) {
if constexpr (std::is_invocable<F, Args...>::value) {
t = f(args...);
} else {
for (size_type i = 0; i < t.size(); i++) fill_seq(t[i], f, args..., i);
}
}
template <typename T> vec<T> make_v(size_type sz) { return vec<T>(sz); }
template <typename T, typename... Tail>
auto make_v(size_type hs, Tail&&... ts) {
auto v = std::move(make_v<T>(std::forward<Tail>(ts)...));
return vec<decltype(v)>(hs, v);
}
namespace init__ {
struct InitIO {
InitIO() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(30);
}
} init_io;
}
template <typename T>
T ceil_pow2(T bound) {
T ret = 1;
while (ret < bound) ret *= 2;
return ret;
}
template <typename T>
T ceil_div(T a, T b) { return a / b + !!(a % b); }
constexpr size_type SIZE = 104;
constexpr size_type offset = SIZE / 2;
mdarray<vec<int>, SIZE, SIZE> qres;
pii query(int i, int j) {
std::cout << "? " << i + 1 << " " << j + 1 << "\n" << std::flush;
int p, q;
std::cin >> p >> q;
return pii(p, q);
}
const vec<int>& get_res(int p, int q) {
return qres[p + offset][q + offset];
}
void set_res(int p, int q, int i) {
qres[p + offset][q + offset].push_back(i);
}
int main() {
int n;
std::cin >> n;
vec<tii> res;
res.reserve(n * n - n - 1);
for (int i = 1; i < n * n - n; i++) {
auto [ p, q ] = query(0, i);
res.emplace_back(p, q, i);
set_res(p, q, i);
}
std::sort(ALL(res));
auto exec = [&](int u, int v) {
int v1 = u / n - v / n;
int v2 = u % n - v % n;
if (v1 > v2) std::swap(v1, v2);
return pii(v1, v2);
};
vec<int> ans(n * n - n, -1);
int v00 = -1, v01 = -1;
int idx10, idx99;
{
auto [ p, q, i ] = res.front();
if (p < 0 || q < 0) {
ans[i] = n * n - 1;
idx99 = i;
} else {
ans[0] = n * n - 1;
idx99 = 0;
v00 = v01 = n - 1;
}
if (p == q) v00 = v01 = p + (n - 1);
}
{
auto [ p, q, i ] = res.back();
if (0 <= p && 0 <= q) {
ans[i] = n;
idx10 = i;
if (v00 == -1) {
int tmp = (p + 1) * n + q;
auto rres = pii(std::get<0>(res.front()), std::get<1>(res.front()));
if (exec(tmp, n * n - 1) == rres) {
v01 = p + 1;
v00 = q;
} else {
v01 = q + 1;
v00 = p;
}
}
} else {
ans[0] = n;
idx10 = 0;
v00 = 0;
v01 = 1;
}
}
ans[0] = v01 * n + v00;
auto check = [&](int v0, int v1) {
auto cnts = make_v<int>(SIZE, SIZE);
for (int v = n; v < n * n; v++) {
int p = v1 - v / n;
int q = v0 - v % n;
if (p == 0 && q == 0) continue;
if (p > q) std::swap(p, q);
cnts[p + offset][q + offset]++;
}
for (int i = -n; i <= n; i++) for (int j = -n; j <= n; j++) {
if (get_res(i, j).size() != cnts[i + offset][j + offset]) return false;
}
return true;
};
if (!check(v00, v01)) std::swap(v00, v01);
auto valid = [&](int v0, int v1) {
return 0 <= v0 && v0 < n &&
1 <= v1 && v1 < n;
};
auto get_valid_v = [&](int d1, int d0, int ov1, int ov0) {
int v0 = ov0 - d0, v1 = ov1 - d1;
if (valid(v0, v1)) return v1 * n + v0;
return (ov1 - d0) * n + (ov0 - d1);
};
for (int i = -n; i <= n; i++) for (int j = -n; j <= n; j++) {
vec<int> rij;
for (int e : get_res(i, j)) if (ans[e] == -1) rij.push_back(e);
if (rij.empty()) continue;
if (rij.size() == 1) {
int tv0 = v00 - i, tv1 = v01 - j;
if (valid(tv0, tv1)) ans[rij[0]] = tv1 * n + tv0;
else ans[rij[0]] = (v01 - i) * n + (v00 - j);
} else {
int idx = (idx10 == 0 ? idx99 : idx10);
int val = (idx10 == 0 ? n * n - 1 : n);
auto [ p, q ] = query(idx, rij[0]);
int vc0 = v00 - i, vc1 = v01 - j, vc = vc1 * n + vc0;
int rvc0 = v00 - j, rvc1 = v01 - i, rvc = rvc1 * n + rvc0;
if (exec(val, vc) == pii(p, q) && exec(val, rvc) == pii(p, q)) {
auto [ pp, qq ] = query(idx99, rij[0]);
if (exec(val, vc) != pii(pp, qq)) std::swap(rij[0], rij[1]);
} else if (exec(val, vc) != pii(p, q)) {
std::swap(rij[0], rij[1]);
}
ans[rij[0]] = vc;
ans[rij[1]] = rvc;
}
}
std::cout << "!";
for (int e : ans) std::cout << ' ' << e;
std::cout << "\n" << std::flush;
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0