QOJ.ac
QOJ
ID | 题目 | 提交者 | 结果 | 用时 | 内存 | 语言 | 文件大小 | 提交时间 | 测评时间 |
---|---|---|---|---|---|---|---|---|---|
#122273 | #5874. Mystery Square | nhuang685 | 0 | 832ms | 3548kb | C++20 | 3.2kb | 2023-07-09 21:56:29 | 2023-07-09 21:56:31 |
Judging History
answer
/**
* @file qoj5874F1.cpp
* @author n685
* @brief
* @date 2023-07-09
*
*
*/
#include <bits/stdc++.h>
#ifdef LOCAL
std::ifstream cin;
std::ofstream cout;
using std::cerr;
#else
using std::cin;
using std::cout;
#define cerr \
if (false) \
std::cerr
#endif
using U = __int128_t;
int n;
const __int128_t ONE = 1;
U s, a;
void print(U v) {
std::string ss;
for (int i = 0; i < n; ++i) {
if ((ONE << i) & v)
ss += "1";
else
ss += "0";
}
std::reverse(ss.begin(), ss.end());
cout << ss << '\n';
}
void solve1() {
bool g = false;
auto gen = [&](auto &self, int node) -> void {
if (node == n) {
U v = s | ((ONE << (n >> 1)) - 1);
U l = 0, r = std::numeric_limits<int64_t>::max();
while (l < r) {
U mid = (l + r + 1) / 2;
if (mid * mid <= v)
l = mid;
else
r = mid - 1;
}
if (((l * l) & s) == s) {
print(l * l);
g = true;
}
return;
}
if (g)
return;
self(self, node + 1);
if (g)
return;
if (a & (ONE << node)) {
s ^= (ONE << node);
self(self, node + 1);
s ^= (ONE << node);
}
};
gen(gen, n / 2);
}
void solve2() {
bool g = false;
auto root = [&](U val, bool second) -> U {
int cnt = 0;
while (val % 2 == 0)
cnt++, val >>= 1;
if (cnt % 2 == 1)
return -1;
U rt = 1;
if (second)
rt ^= 2;
U v = 0;
for (int i = 2; i < (n + 1) / 2 - cnt / 2; ++i) {
U m = (ONE << (i + 2));
v = rt;
v = ((v * v) & (m - 1));
U res = val & (m - 1);
if (v != res)
rt ^= (ONE << i);
}
return rt << cnt / 2;
};
auto gen = [&](auto &self, int node) -> void {
if (node == (n + 1) / 2 + 2) {
U rt1 = root(s, false);
U rt2 = root(s, true);
if (((rt1 * rt1) & s) == s) {
print(rt1 * rt1);
g = true;
} else if (((rt2 * rt2) & s) == s) {
print(rt2 * rt2);
g = true;
}
return;
}
if (g)
return;
self(self, node + 1);
if (g)
return;
if ((a & (ONE << node))) {
s ^= (ONE << node);
self(self, node + 1);
s ^= (ONE << node);
}
};
gen(gen, 0);
}
void solve() {
std::string ss;
cin >> ss;
std::reverse(ss.begin(), ss.end());
n = (int)ss.size();
s = 0, a = 0;
for (int i = 0; i < n; ++i) {
if (ss[i] == '1')
s ^= (ONE << i);
else if (ss[i] == '?')
a ^= (ONE << i);
}
int cnt1 = __builtin_popcountll((unsigned long long)(a >> (n >> 1)));
int cnt2 = __builtin_popcountll(
(unsigned long long)(a & ((ONE << ((n + 1) / 2 + 1)) - 1)));
if (cnt2 < cnt1)
solve2();
else
solve1();
}
int main() {
#ifdef LOCAL
cin.open("input.txt");
cout.rdbuf()->pubsetbuf(0, 0);
cout.open("output.txt");
#else
cin.tie(nullptr)->sync_with_stdio(false);
#endif
int t;
cin >> t;
for (int tt = 1; tt <= t; ++tt) {
cout << "Case #" << tt << ": ";
solve();
}
}
詳細信息
Subtask #1:
score: 0
Wrong Answer
Test #1:
score: 0
Wrong Answer
time: 1ms
memory: 3520kb
input:
25 1??? 1 10??110??00??1000?? 1??010?0110?1010?0?010?0111011?11100?100010?0??0??1 1??11????00??1?1?0?1??01??110110?11?00100110?00100?0?00 11?1?1???11111?11?1??11110000?00?????00??0?000?000?1 10??000000?0?00000?00000000??0?0000???00??????0000??? 101???11??11000?????1??1?1??10??0?0100011?0001?01011001...
output:
Case #1: 1001 Case #2: 1 Case #3: 1011110110000100001 Case #4: 111010001100101000001010111011011100110001000110001 Case #5: 1101111110000101100101010111011001110010011000010000100 Case #6: 1101110001111101101001111010000000011011011100100001 Case #7: 1000000000000000000000000000000000000000000000000...
result:
wrong answer 6th lines differ - expected: 'Case #6: 1111111111111111111111111000000000000000000000000001', found: 'Case #6: 1101110001111101101001111010000000011011011100100001'
Subtask #2:
score: 0
Wrong Answer
Test #2:
score: 0
Wrong Answer
time: 832ms
memory: 3548kb
input:
25 1????????????????????111101010000011100110101111000001011111100110000011000101100000010010110100101000???????????????????? 10?11100?000111??11?01010110100??1?100111?001000000??0101?110?0111?011?11?1??00010111?010??100?100??10?010?001001110111110?1 1000100111100100110011010111100001111010?????????...
output:
Case #1: 10111001010101110000011110101000001110011010111100000101111110011110111101010110011101001011111011111000001100000000110001 Case #2: 1011110000001110111001010110100001110011100010000001101010110001111011111110000010111101010100010010101010100100111011111001 Case #3: 1000111111111111111111111...
result:
wrong answer 1st lines differ - expected: 'Case #1: 111001011101010101101...1010010100001101011000010100001', found: 'Case #1: 101110010101011100000...1111011111000001100000000110001'