Problem p02651 (C++) — buggy submission, verdict: Time Limit Exceeded


#include <algorithm>
#include <array>
#include <bitset>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <vector>

long long mod = 1e9 + 7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a) {
    x = a % mod;
    while (x < 0) {
      x += mod;
    }
  };
  Mint &operator+=(const Mint &a) {
    x += a.x;
    x %= mod;
    return *this;
  }
  Mint &operator-=(const Mint &a) {
    x += (mod - a.x);
    x %= mod;
    return *this;
  }
  Mint &operator*=(const Mint &a) {
    x *= a.x;
    x %= mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const {
    if (n == 0)
      return Mint(1);
    Mint y = pow(n >> 1); // pow(n/2)を計算する
    y *= y;
    if (n % 2 == 1)
      y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const { return a.pow(mod - 2); }

  Mint &operator/=(const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator+(Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator-(Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator*(Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator/(Mint &a) const {
    Mint y(*this);
    y /= a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint iy = Mint(1);
    Mint one = Mint(1);
    // 割り算の演算は時間がかかるので最後に1度だけ行うようにすること
    for (Mint i(0); (i.x) < k; i.x++) {
      y *= (n - i);
      iy *= (i + one);
    }
    return y / iy;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x) < k; i.x++) {
      y *= (n - i);
    }
    return y;
  }
};

class UnionFind {
private:
  int n;
  std::vector<int> parent;

public:
  UnionFind(int num) : n(num) {
    parent = std::vector<int>(n);
    for (int i = 0; i < n; i++) {
      parent[i] = i;
    }
  }
  int GetRoot(int i) {
    int n = i;
    while (parent[n] != n) {
      n = parent[n];
    }
    parent[i] = n;
    return n;
  }

  bool SameGroup(int n, int m) {
    n = this->GetRoot(n);
    m = this->GetRoot(m);
    return n == m;
  }

  bool Unite(int n, int m) {
    n = this->GetRoot(n);
    m = this->GetRoot(m);
    if (n == m)
      return false;
    parent[n] = m;
    return true;
  }
};

int getgcd(int a, int b) {
  int max = std::max(a, b);
  int min = std::min(a, b);
  if (min == 0)
    return max;
  return getgcd(min, max % min);
}

Mint mynCk(int n, int k) {
  if (2 * k > n)
    return mynCk(n, n - k);
  Mint retval(1);
  Mint iretval(1);
  for (int i = 0; i < k; i++) {
    retval *= Mint(n - i);
  }
  for (int i = 1; i <= k; i++) {
    iretval *= Mint(i);
  }
  return retval / iretval;
}
long long doubling[58][200004];

int main() {
  int T;
  std::cin >> T;
  std::vector<int> ans;
  for (int t = 0; t < T; t++) {
    int N;
    std::cin >> N;
    std::vector<long long> A(N);
    for (int i = 0; i < N; i++) {
      std::cin >> A[i];
    }
    std::reverse(A.begin(), A.end());
    std::string s;
    std::cin >> s;
    std::reverse(s.begin(), s.end());
    std::vector<long long> base;
    auto push_base = [&](long long a) {
      for (long long b : base) {
        a = std::min(a, a ^ b);
      }
      if (a != 0)
        base.push_back(a);
    };
    auto check = [&](long long value) {
      for (long long b : base) {
        value = std::min(value, value ^ b);
      }
      return value == 0;
    };

    bool ok = true;
    for (int i = 0; i < N; i++) {
      if (s[i] == '0') {
        push_base(A[i]);
      } else {
        if (!check(A[i])) {
          ok = false;
          break;
        }
      }
    }
    if (ok)
      ans.push_back(0);
    else
      ans.push_back(1);
  }
  for (int p : ans) {
    std::cout << p << std::endl;
  }
  return 0;
}

Error: TLE

Fixed submission:

#include <algorithm>
#include <deque>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <utility>
#include <vector>

long long A[104][204];

int main() {
  int T;
  scanf("%d", &T);
  std::vector<int> N(T);
  std::vector<std::string> S(T);
  for (int t = 0; t < T; t++) {
    scanf("%d", &N[t]);
    for (int i = 0; i < N[t]; i++) {
      scanf("%lld", &A[t][i]);
    }
    std::cin >> S[t];
  }
  for (int t = 0; t < T; t++) {
    //    std::vector<int > win(N[t]+4, -1); // 1:can0, -1:cannot0
    // std::vector<int > winlist;
    std::set<long long> winlist;
    winlist.insert(0);
    for (int i = N[t] - 1; i >= 0; i--) {
      // printf("%c\\n", S[t][i]);
      if (S[t][i] == '0') {
        std::queue<long long> queue;
        for (auto &entry : winlist) {
          queue.push((long long)entry ^ A[t][i]);
        }
        while (queue.size() > 0) {
          winlist.insert(queue.front());
          queue.pop();
        }
      } else {
        std::queue<long long> queue;
        for (auto &entry : winlist) {
          auto itr = winlist.find(A[t][i] ^ (long long)entry);
          if (itr == winlist.end()) {
            // winlistにないやつにとべる
            // winlist.erase(entry);
            queue.push(entry);
          }
        }
        while (queue.size() > 0) {
          winlist.erase(queue.front());
          queue.pop();
        }
      }
    }
    auto itr2 = winlist.find(0);
    if (itr2 == winlist.end()) {
      std::cout << 1 << std::endl;
    } else {
      std::cout << 0 << std::endl;
    }
  }

  return 0;
}