QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#122273#5874. Mystery Squarenhuang6850 832ms3548kbC++203.2kb2023-07-09 21:56:292023-07-09 21:56:31

Judging History

你现在查看的是最新测评结果

  • [2023-08-10 23:21:45]
  • System Update: QOJ starts to keep a history of the judgings of all the submissions.
  • [2023-07-09 21:56:31]
  • 评测
  • 测评结果:0
  • 用时:832ms
  • 内存:3548kb
  • [2023-07-09 21:56:29]
  • 提交

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'