Problem:
バトンリレーゲーム
アカベ高校では、毎年全校生徒が参加するゲームを行っています。まず、校庭に
N
人の全校生徒が円形に並びます。図のように、各生徒は 0 から
N
-1 までの番号が書かれたゼッケンを付けています。
ゲームではバトンを１本使い、最初はゼッケン 0 番の生徒がバトンを持っています。そこから、以下の手順を
M
回繰り返します。まず、現時点でバトンを持っている生徒が適当な正の整数
a
を宣言します。
a
が偶数のときは時計回り、奇数のときは反時計回りに隣の生徒にバトンを渡していき、
a
番目にバトンを受け取った生徒が脱落します。脱落した生徒は、時計回りで隣の生徒にバトンを渡し、円から抜けます。
ゲームが終わった後に円に残った生徒は、放課後の掃除が１年間免除されます。しかし、ここ数年は生徒数が増えたため、全校生徒を集めるのが難しくなってきています。そこで、競技プログラミング部のあなたは、シミュレーションで掃除が免除される生徒を求めるプログラムを作成するよう頼まれました。
指定した生徒が掃除を免除されているかどうかを質問したとき、それに答えるプログラムを作成してください。
入力
入力は以下の形式で与えられる。
N
M
Q
a
1
a
2
...
a
M
q
1
q
2
...
q
Q
入力は３行であり、１行目に生徒の人数
N
(10 ≤
N
≤ 200000)、繰り返し回数
M
(5 ≤
M
<
N
)、生徒が掃除を免除されるかどうかを問い合わせる質問の個数
Q
(1 ≤
Q
≤ 1000) が与えられる。続く１行に、
i
回目の繰り返しで最初にバトンを持っている生徒が宣言する整数
a
i
(1 ≤
a
i
≤ 100) が与えられる。続く１行に、質問としてゼッケン番号
q
i
(0 ≤
q
<
N
) が与えられる。
出力
質問ごとに、ゼッケン番号
q
i
の生徒が掃除を免除されるかどうかを
i
行目に出力する。掃除が免除されるなら 1 を、されないなら 0 を出力する。
入出力例
入力例
10 5 3
2 6 5 18 3
3 0 5
出力例
1
0
1

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
#include <iomanip>
#include <numbers>
#include <cassert>
#include <numeric>
#ifdef _MSC_VER
#include <intrin.h>
#endif
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
template<typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
template<typename T>
bool chmax(T & a, const T & b) { if (a < b) { a = b; return true; } return false; }
template<typename T>
bool chmin(T & a, const T & b) { if (a > b) { a = b; return true; } return false; }
const int inf = 1e9;
const ll linf = 1e18;
const int dy[] = { 0,0,1,-1 }, dx[] = { 1,-1,0,0 };
int main() {
    int n, m, Q; cin >> n >> m >> Q;
    set<int> st;
    rep(i, n)st.insert(i);
    vector<bool> b(n, true);
    auto it = st.begin();
    rep(i, m) {
        int a; cin >> a;
        bool rev = a % 2;
        rep(j, a) {
            if (!rev) {
                if (next(it) == st.end())it = st.begin();
                else it++;
            }
            else {
                if (it == st.begin())it = prev(st.end());
                else it--;
            }
        }
        b[*it] = false;
        auto del = it;
        if (next(it) == st.end())it = st.begin();
        else it++;
        st.erase(del);
    }
    rep(i, Q) {
        int q; cin >> q;
        cout << b[q] << endl;
    }
}
accuracy: 1
time_ms: 150
memory_kb: 13056
final_rank: 14

code_snippet: #include <bits/stdc++.h>
using namespace std;
// #include<atcoder/all>
// using mint = atcoder::modint998244353;
using ld = long double;
#define fi first
#define se second
#define all(x) x.begin(),x.end()
#define rep(i,n) for(int i=0;i<(int)(n);++i)
template<typename T>bool chmin(T&a,T b){return b<a?(a=b,1):0;}
template<typename T>bool chmax(T&a,T b){return b>a?(a=b,1):0;}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N,M,Q;
    cin>>N>>M>>Q;
    vector<int> ans(N,1);

    vector<int> R(N),L(N);
    rep(i,N) R[i]=(i+1)%N;
    rep(i,N) L[i]=(i+N-1)%N;
    int now=0;
    rep(_,M){
        int a;
        cin>>a;
        rep(_,a) now=(a%2?L:R)[now];
        int d=now;
        now=R[now];
        L[R[d]]=L[d];
        R[L[d]]=R[d];
        ans[d]=0;
    }

    rep(i,Q){
        int q;
        cin>>q;
        cout<<ans[q]<<"\n";
    }
}
accuracy: 1
time_ms: 20
memory_kb: 5760
final_rank: 8

code_snippet: // 7

#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1ll<<29;
const bool debug = 0;

int N, M, Q;
bool valid[212345];
int a[212345];

int main() {
	cin >> N >> M >> Q;
	REP(i, M) scanf("%d", a + i);
	
	fill(valid, valid + N, 1);
	
	list<int> lis;
	REP(i, N) lis.insert(lis.end(), i);
	
	list<int>::iterator it = lis.begin();
	
	REP(i, M) {
		REP(j, a[i]) {
			if (a[i] & 1) { // 反時計周り
				--it;
				if (it == lis.end()) --it;
			}
			else { // 時計回り
				++it;
				if (it == lis.end()) ++it;
			}
		}
		
		valid[*it] = false;
		it = lis.erase(it);
		if (it == lis.end()) ++it;
	}
	
	
	REP(i, Q) {
		int q;
		scanf("%d", &q);
		printf("%d\n", valid[q]);
	}
	
	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 10728
final_rank: 12

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define FOR(i,s,t) for(int i = s ; i < t ; ++i)
#define ALL(a) a.begin(),a.end()
#define SORT(a) sort(ALL(a))
#define UNIQ(a) a.erase(unique(ALL(a)),a.end())
#define debug(a) cerr<<#a":="<<a<<endl
#define SZ(a) (int)a.size()
using LL = long long; template<class T> using V = vector<T>; template<class T> using VV = V<V<T>>;

template<typename type>
struct BIT0 { // 0-index
	int N;
	int nn;
	vector<type> data;
	//動的はmap<int?,type>data
	BIT0(int n) {
		N = n + 1;
		data = vector<type>(n + 1, 0);
		nn = 1;
		while (nn * 2 <= N)nn *= 2;
	}
	void add(int i, type w) { // a[i] += w
		i++;
		for (int x = i; x < N; x += x & -x) {
			data[x] += w;
		}
	}
	type sum(int i) { // iまでの和 [0,i)
		type ret = 0;
		for (int x = i; x > 0; x -= x & -x) {
			ret += data[x];
		}
		return ret;
	}
	// [l, r)
	type sum(int l, int r) {
		return sum(r) - sum(l);
	}

	/*	BIT 上で二分探索
	二分木の分かれ方に従って二分探索する
	左の子に進むか右の子に進むかを知るためには，左の子の範囲の和がわかればよい
	ちょうど BIT がもっている情報，O(1) 時間で得られる
	a[1] + a[2] + a[3] + ... a[x] >= w となる最小のxを返す、ただしa[i] >= 0	*/

	int lower_bound(type w) {//  w≦[0,x]以上となる最小のindex,x
		if (w <= 0) return 0;
		int x = 0;
		for (int k = nn; k > 0; k /= 2) {
			if (x + k <= N && data[x + k] < w) {
				w -= data[x + k];
				x += k;
			}
		}
		return x;
	}
};

int main() {
	cin.tie(0);
	ios_base::sync_with_stdio(false);


	int N, M, Q;
	cin >> N >> M >> Q;
	V<int>a(M);
	FOR(i, 0, M) {
		cin >> a[i];
	}
	BIT0<int>bit(N);
	FOR(i, 0, N) {
		bit.add(i, 1);
	}
	// 常に右にわたすことに注意
	int button = 0;

	auto buttonPass = [&bit, N](int target) {
		// targetからみて次の増加番号の人にバトンを渡す
		int presum = bit.sum(0, target);// bit[target]は0

		if (bit.sum(target, N)) {//1人でもいる
			return  bit.lower_bound(presum + 1);
		}
		else {
			return bit.lower_bound(1);
		}
	};

	FOR(i, 0, M) {
		int plus = a[i];
		if (plus % 2 == 0) {// 右
			plus %= bit.sum(0,N);
			if (bit.sum(button + 1, N) >= plus) {// 渡せる
				int sum = bit.sum(0, button + 1);
				int target = bit.lower_bound(sum + plus);
				bit.add(target, -1);
				// バトンをtargetの右に渡す
				button = buttonPass(target);
			}
			else { // またいで渡す
				plus -= bit.sum(button + 1, N);
				button = 0;
				int target = bit.lower_bound(plus);
				bit.add(target, -1);

				// バトンをtargetの右に渡す
				button = buttonPass(target);
			}
		}
		else { //左
			plus %= bit.sum(0, N);
			if (bit.sum(0, button) >= plus) {// ぽい
				int sum = bit.sum(0, button);
				int target = bit.lower_bound(sum - plus + 1);
				bit.add(target, -1);
				//バトンをtargetの右に渡す
				button = buttonPass(target);

			}
			else {// ぽいではない
				plus -= bit.sum(0, button);
				button = N - 1;
				int sum = bit.sum(0, button + 1);
				int target = bit.lower_bound(sum - plus + 1);
				bit.add(target, -1);

				//バトンをtargetの右に渡す
				button = buttonPass(target);
			}
		}
	}

	FOR(i, 0, Q) {
		int q; cin >> q;
		cout << bit.sum(q, q + 1) << endl;
		// 1(免除)->存在 or 0
	}
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 4524
final_rank: 1

code_snippet: #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,N) for(ll i=0;i<N;i++)
#define all(x) x.begin(),x.end()
#define fi first
#define se second
#define pb push_back
#define eb emplace_back


int main(){
    ll N,M,Q;cin>>N>>M>>Q;
    vector<int>A(M);
    rep(i,M)cin>>A[i];
    vector<pair<int,int>>D(N);
    vector<bool>out(N,false);
    rep(i,N){
        D[i].se = (i+1)%N;
        D[i].fi = (N+i-1)%N;
    }
    int v = 0;
    rep(i,M){
        if(A[i]%2==0){
            rep(k,A[i]){
                v = D[v].se;
            }
        }
        else {
            rep(k,A[i]){
                v = D[v].fi;
            }
        }
        out[v] = true;
        D[D[v].se].fi = D[v].fi;
        D[D[v].fi].se = D[v].se;
        v = D[v].se;
    }
    rep(i,Q){
        int q;cin>>q;
        if(out[q])cout<<0<<endl;
        else cout<<1<<endl;
    }
}
accuracy: 1
time_ms: 40
memory_kb: 5496
final_rank: 7

code_snippet: #include <bits/stdc++.h>
using namespace std;


#include <algorithm>
#include <cassert>
#include <functional>
#include <vector>


#ifdef _MSC_VER
#include <intrin.h>
#endif

#if __cplusplus >= 202002L
#include <bit>
#endif

namespace atcoder {

namespace internal {

#if __cplusplus >= 202002L

using std::bit_ceil;

#else

unsigned int bit_ceil(unsigned int n) {
    unsigned int x = 1;
    while (x < (unsigned int)(n)) x *= 2;
    return x;
}

#endif

int countr_zero(unsigned int n) {
#ifdef _MSC_VER
    unsigned long index;
    _BitScanForward(&index, n);
    return index;
#else
    return __builtin_ctz(n);
#endif
}

constexpr int countr_zero_constexpr(unsigned int n) {
    int x = 0;
    while (!(n & (1 << x))) x++;
    return x;
}

}  // namespace internal

}  // namespace atcoder


namespace atcoder {

#if __cplusplus >= 201703L

template <class S, auto op, auto e> struct segtree {
    static_assert(std::is_convertible_v<decltype(op), std::function<S(S, S)>>,
                  "op must work as S(S, S)");
    static_assert(std::is_convertible_v<decltype(e), std::function<S()>>,
                  "e must work as S()");

#else

template <class S, S (*op)(S, S), S (*e)()> struct segtree {

#endif

  public:
    segtree() : segtree(0) {}
    explicit segtree(int n) : segtree(std::vector<S>(n, e())) {}
    explicit segtree(const std::vector<S>& v) : _n(int(v.size())) {
        size = (int)internal::bit_ceil((unsigned int)(_n));
        log = internal::countr_zero((unsigned int)size);
        d = std::vector<S>(2 * size, e());
        for (int i = 0; i < _n; i++) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x) {
        assert(0 <= p && p < _n);
        p += size;
        d[p] = x;
        for (int i = 1; i <= log; i++) update(p >> i);
    }

    S get(int p) const {
        assert(0 <= p && p < _n);
        return d[p + size];
    }

    S prod(int l, int r) const {
        assert(0 <= l && l <= r && r <= _n);
        S sml = e(), smr = e();
        l += size;
        r += size;

        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }

    S all_prod() const { return d[1]; }

    template <bool (*f)(S)> int max_right(int l) const {
        return max_right(l, [](S x) { return f(x); });
    }
    template <class F> int max_right(int l, F f) const {
        assert(0 <= l && l <= _n);
        assert(f(e()));
        if (l == _n) return _n;
        l += size;
        S sm = e();
        do {
            while (l % 2 == 0) l >>= 1;
            if (!f(op(sm, d[l]))) {
                while (l < size) {
                    l = (2 * l);
                    if (f(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return _n;
    }

    template <bool (*f)(S)> int min_left(int r) const {
        return min_left(r, [](S x) { return f(x); });
    }
    template <class F> int min_left(int r, F f) const {
        assert(0 <= r && r <= _n);
        assert(f(e()));
        if (r == 0) return 0;
        r += size;
        S sm = e();
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!f(op(d[r], sm))) {
                while (r < size) {
                    r = (2 * r + 1);
                    if (f(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

  private:
    int _n, size, log;
    std::vector<S> d;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

}  // namespace atcoder

using namespace atcoder;

int e() { return 0; }
int op(int x, int y) { return x + y; }

bool f(int x) { return x == 0; }

int main() {
  int N, M, Q;
  cin >> N >> M >> Q;
  vector<int> seg_init(N, 1);
  segtree<int, op, e> seg(seg_init);
  auto next_clockwise = [&](int i) -> int {
    return (seg.prod(i + 1, N) == 0 ? seg.max_right<f>(0) : seg.max_right<f>(i + 1));
  };
  auto prev_clockwise = [&](int i) -> int {
    return (seg.prod(0, i) == 0 ? seg.min_left<f>(N) - 1 : seg.min_left<f>(i) - 1);
  };
  int b = 0;
  while(M--) {
    int a;
    cin >> a;
    if(a % 2 == 0) {
      while(a--) b = next_clockwise(b);
      seg.set(b, 0);
      b = next_clockwise(b);
    }else {
      while(a--) b = prev_clockwise(b);
      seg.set(b, 0);
      b = next_clockwise(b);
    }
  }
  while(Q--) {
    int q;
    cin >> q;
    cout << seg.get(q) << "\n";
  }
}
accuracy: 1
time_ms: 900
memory_kb: 5876
final_rank: 16

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
#include <string>
#include <bitset>
#include <queue>
#define ll long long
using namespace std;

int main(){
    int n,m,q; cin >> n >> m >> q;
    deque<int> p;
    for(int i = 0;i < n;i++) p.push_back(i);
    for(int i = 0;i < m;i++){
        int a;cin >> a;
        if(a % 2 == 0){
            for(int j = 0;j < a;j++){
                p.push_back(p.at(0));
                p.pop_front();
            }
        }else{
            for(int j = 0;j < a;j++){
                p.push_front(p.at(p.size() - 1));
                p.pop_back();
            }
        }
        p.pop_front();
    }
    vector<int> ans(n,0);
    for(int i : p) ans[i] = 1;
    for(int i = 0;i < q;i++){
        int s;cin >> s; cout << ans[s] << endl;
    }
}
accuracy: 1
time_ms: 60
memory_kb: 4644
final_rank: 3

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef struct L{int f,b;}List;
int main(void)
{
    int n,m,q;
    cin>>n>>m>>q;
    List s[n+1];
    vector<int> f(n+1,1);
    for(int i=0;i<n;i++){
        s[i].f=i+1; s[i].b=i-1;
    }
    s[n-1].f=0; s[0].b=n-1;
    int p=0;
    for(int i=0;i<m;i++){
        int a; cin>>a;
        for(int j=0;j<a;j++){
            if(a%2) p=s[p].b;
            else p=s[p].f;
        }
        s[s[p].b].f=s[p].f;
        s[s[p].f].b=s[p].b;
        f[p]=0; p=s[p].f;
    }
    for(int i=0;i<q;i++){
        int a; cin>>a;
        cout<<f[a]<<endl;
    }
    return 0;
}
accuracy: 1
time_ms: 60
memory_kb: 5132
final_rank: 5

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <list>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)

template<class T>
using vi = vector<T>;

template<class T>
using vii = vector<vi<T>>;

template<class T>
using viii = vector<vii<T>>;

using pii = pair<int, int>;

int main()
{
    int n, m, Q;
    cin >> n >> m >> Q;
    vi<int> a(m), q(Q);
    rep(i, m) cin >> a[i];
    rep(i, Q) cin >> q[i];

    list<int> lst;
    const int inf = 1e9;
    lst.push_back(-inf);
    rep(i, n) lst.push_back(i);
    lst.push_back(inf);
    auto itr = lst.begin();
    itr++;
    rep(i, m) {
        if (a[i] % 2 == 0) {
            rep(j, a[i]) {
                itr++;
                if (*itr == inf) {
                    itr = lst.begin();
                    itr++;
                }
            }
        }
        else {
            rep(j, a[i]) {
                itr--;
                if (*itr == -inf) {
                    itr = lst.end();
                    itr--;
                    itr--;
                }
            }
        }
        itr = lst.erase(itr);
        if (*itr == inf) {
            itr = lst.begin();
            itr++;
        }
    }
    vi<int> check(n);
    for (auto it = lst.begin(); it != lst.end(); it++) {
        if (abs(*it) == inf) continue;
        check[*it] = 1;
    }

    rep(i, Q) cout << check[q[i]] << endl;
    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 10240
final_rank: 11

code_snippet: #pragma GCC optimize("Ofast")
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <queue>
#include <cstdio>
#include <ctime>
#include <assert.h>
#include <chrono>
#include <random>
#include <numeric>
#include <set>
#include <deque>
#include <stack>
#include <sstream>
#include <utility>
#include <cstring>
#include <unordered_map>
#include <unordered_set>
#include <tuple>
#include <array>
#include <bitset>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}
inline double time() {
    return static_cast<long double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count()) * 1e-9;
}


int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n,m,q; cin >> n >> m >> q;
    vector<int> nxt(n),pre(n);
    for(int i=0;i<n;i++){
        nxt[i] = (i+1)%n;
        pre[i] = (i+n-1)%n;
    }
    int cur = 0;
    vector<bool> fail(n,false);
    while(m--){
        int a; cin >> a;
        if(a&1){
            while(a--){
                cur = pre[cur];
            }
        }
        else{
            while(a--){
                cur = nxt[cur];
            }
        }
        fail[cur] = true;
        nxt[pre[cur]] = nxt[cur];
        pre[nxt[cur]] = pre[cur];
        cur = nxt[cur];
    }
    while(q--){
        int a; cin >> a;
        if(fail[a]){
            cout << 0 << "\n";
        }
        else{
            cout << 1 << "\n";
        }
    }
}
accuracy: 1
time_ms: 30
memory_kb: 4568
final_rank: 2

code_snippet: #include <iostream>

using namespace std;

int v[200002], l[200002], r[200002];

int main() {

	int N, M, Q;
	int at = 0, m, q;

	cin >> N >> M >> Q;


	for (int i = 0; i < N; i++) {
		v[i] = 1;
		l[i] = (i + N - 1) % N;
		r[i] = (i + 1) % N;
	}

	for (int i = 0; i < M; i++) {
		cin >> m;

		if (m % 2)
			for (int j = 0; j < m; j++)
				at = l[at];
		else
			for (int j = 0; j < m; j++)
				at = r[at];

		v[at] = 0;
		int tmpL = l[at], tmpR = r[at];
		l[tmpR] = tmpL;
		r[tmpL] = tmpR;
		at = tmpR;

	}

	for (int i = 0; i < Q; i++) {
		cin >> q;
		cout << v[q] << endl;
	}


	return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 5452
final_rank: 9

code_snippet: #include <iostream>
#include <queue>
#include <vector>
#include <string.h>

using namespace std;

int main() {

	int N, M, Q, tmp;
	queue<int> a;
	int ans[200002];
	vector<int> q;
	vector<int> an;

	memset(ans, -1, sizeof(ans));

	cin >> N >> M >> Q;

	for (int i = 0; i < M; i++)
		cin >> tmp, a.push(tmp);

	for (int i = 0; i < Q; i++)
		cin >> tmp, q.push_back(tmp);


	int n = a.front() % 2 == 0 ? 0 : N - 1;
	while (!a.empty()) {
		int A = a.front();
		a.pop();
		bool isEven = A % 2 == 0;

		for (int i = 0; i < A; i++) {
			isEven ? n++ : n--;
			if (n == N)
				n = 0;
			if (n < 0)
				n = N - 1;
			while (ans[n] == 0) {
				isEven ? n++ : n--;
				if (n == N)
					n = 0;
				if (n < 0)
					n = N - 1;
			}
		}
		ans[n] = 0;
		an.push_back(n);
		n++;
		if (n == N)
			n = 0;
		while (ans[n] == 0) {
			n++;
			if (n == N)
				n = 0;
		}
	}

	for (vector<int>::iterator i = q.begin(); i != q.end(); i++) {
		bool isP = false;
		for (vector<int>::iterator j = an.begin(); j != an.end(); j++) {
			if (*i == *j) {
				isP = true;
				break;
			}
		}
		cout << (isP ? 0 : 1) << endl;
	}



	return 0;
}
accuracy: 0.5555555555555556
time_ms: 350
memory_kb: 5436
final_rank: 17

code_snippet: #include <iostream>
#include <queue>
#include <vector>
#include <string.h>

using namespace std;

bool isRead(int n, vector<int> &ans) {
	for (vector<int>::iterator i = ans.begin(); i != ans.end(); i++)
		if (*i == n)
			return true;
	return false;
}

int main() {

	int N, M, Q, tmp;
	queue<int> a;
	int ans[200002];
	vector<int> q;
	vector<int> an;

	memset(ans, -1, sizeof(ans));

	cin >> N >> M >> Q;

	for (int i = 0; i < M; i++)
		cin >> tmp, a.push(tmp);

	for (int i = 0; i < Q; i++)
		cin >> tmp, q.push_back(tmp);


	int n = a.front() % 2 == 0 ? 0 : N - 1;
	while (!a.empty()) {
		int A = a.front();
		a.pop();
		bool isEven = A % 2 == 0;

		for (int i = 0; i < A; i++) {
			isEven ? n++ : n--;
			if (n == N)
				n = 0;
			if (n < 0)
				n = N - 1;
			while (ans[n] == 0) {
				isEven ? n++ : n--;
				if (n == N)
					n = 0;
				if (n < 0)
					n = N - 1;
			}
		}
		ans[n] = 0;
		an.push_back(n);
		n++;
		if (n == N)
			n = 0;
		while (ans[n] == 0) {
			n++;
			if (n == N)
				n = 0;
		}
	}

	for (vector<int>::iterator i = q.begin(); i != q.end(); i++) {
		bool isP = false;
		for (vector<int>::iterator j = an.begin(); j != an.end(); j++) {
			if (*i == *j) {
				isP = true;
				break;
			}
		}
		cout << (isP ? 0 : 1) << endl;
	}



	return 0;
}
accuracy: 0.5555555555555556
time_ms: 350
memory_kb: 5436
final_rank: 17

code_snippet: #include <iostream>
#include <queue>
#include <vector>

using namespace std;

bool isRead(int n, vector<int> &ans) {
	for (vector<int>::iterator i = ans.begin(); i != ans.end(); i++)
		if (*i == n)
			return true;
	return false;
}

int main() {

	int N, M, Q, tmp;
	queue<int> a;
	vector<int> ans;
	vector<int> q;

	cin >> N >> M >> Q;

	for (int i = 0; i < M; i++)
		cin >> tmp, a.push(tmp);

	for (int i = 0; i < Q; i++)
		cin >> tmp, q.push_back(tmp);


	int n = a.front() % 2 == 0 ? 0 : N - 1;
	while (!a.empty()) {
		int A = a.front();
		a.pop();
		bool isEven = A % 2 == 0;

		for (int i = 0; i < A; i++) {
			isEven ? n++ : n--;
			if (n == N)
				n = 0;
			if (n < 0)
				n = N - 1;
			while (isRead(n, ans)) {
				isEven ? n++ : n--;
				if (n == N)
					n = 0;
				if (n < 0)
					n = N - 1;
			}
		}
		ans.push_back(n);
		n++;
		while (isRead(n, ans)) {
			isEven ? n++ : n--;
			if (n == N)
				n = 0;
			if (n < 0)
				n = N - 1;
		}
	}

	for (vector<int>::iterator i = q.begin(); i != q.end(); i++) {
		bool isP = false;
		for (vector<int>::iterator j = ans.begin(); j != ans.end(); j++) {
			if (*i == *j) {
				isP = true;
				break;
			}
		}
		cout << (isP ? 0 : 1) << endl;
	}

	return 0;
}
accuracy: 0.1111111111111111
time_ms: 40
memory_kb: 3100
final_rank: 20

code_snippet: #include <iostream>
#include <queue>
#include <vector>

using namespace std;

bool isRead(int n, vector<int> &ans) {
	for (vector<int>::iterator i = ans.begin(); i != ans.end(); i++)
		if (*i == n)
			return true;
	return false;
}

int main() {

	int N, M, Q, tmp;
	queue<int> a;
	vector<int> ans;
	vector<int> q;

	cin >> N >> M >> Q;

	for (int i = 0; i < M; i++)
		cin >> tmp, a.push(tmp);

	for (int i = 0; i < Q; i++)
		cin >> tmp, q.push_back(tmp);


	int n = a.front() % 2 == 0 ? 0 : N - 1;
	while (!a.empty()) {
		int A = a.front();
		a.pop();
		bool isEven = A % 2 == 0;

		for (int i = 0; i < A; i++) {
			isEven ? n++ : n--;
			if (n == N)
				n = 0;
			if (n < 0)
				n = N - 1;
			while (isRead(n, ans)) {
				isEven ? n++ : n--;
				if (n == N)
					n = 0;
				if (n < 0)
					n = N - 1;
			}
		}
		ans.push_back(n);
		n++;
		if (n == N)
			n = 0;
	}

	for (vector<int>::iterator i = q.begin(); i != q.end(); i++) {
		bool isP = false;
		for (vector<int>::iterator j = ans.begin(); j != ans.end(); j++) {
			if (*i == *j) {
				isP = true;
				break;
			}
		}
		cout << (isP ? 0 : 1) << endl;
	}

	return 0;
}
accuracy: 0.1111111111111111
time_ms: 30
memory_kb: 3092
final_rank: 19

code_snippet: #include <bits/stdc++.h>
using namespace std;
struct binary_indexed_tree{
  int N;
  vector<int> BIT;
  binary_indexed_tree(int N): N(N), BIT(N + 1, 0){
  }
  void add(int i, int x){
    i++;
    while (i <= N){
      BIT[i] += x;
      i += i & -i;
    }
  }
  int sum(int i){
    int ans = 0;
    while (i > 0){
      ans += BIT[i];
      i -= i & -i;
    }
    return ans;
  }
  int sum(int L, int R){
    return sum(R) - sum(L);
  }
};
int main(){
  int N, M, Q;
  cin >> N >> M >> Q;
  vector<int> a(M);
  for (int i = 0; i < M; i++){
    cin >> a[i];
  }
  set<int> st;
  for (int i = 0; i < N; i++){
    st.insert(i);
  }
  binary_indexed_tree BIT(N);
  for (int i = 0; i < N; i++){
    BIT.add(i, 1);
  }
  int p = 0;
  for (int i = 0; i < M; i++){
    if (a[i] % 2 == 0){
      a[i] %= N - i;
      if (a[i] == 0){
        a[i] = N - i;
      }
      int S = BIT.sum(p + 1, N);
      if (S >= a[i]){
        int tv = p + 1, fv = N;
        while (fv - tv > 1){
          int mid = (tv + fv) / 2;
          if (BIT.sum(p + 1, mid) < a[i]){
            tv = mid;
          } else {
            fv = mid;
          }
        }
        p = tv;
      } else {
        int tv = 0, fv = p + 1;
        while (fv - tv > 1){
          int mid = (tv + fv) / 2;
          if (S + BIT.sum(mid) < a[i]){
            tv = mid;
          } else {
            fv = mid;
          }
        }
        p = tv;
      }
    } else {
      a[i] %= N - i;
      if (a[i] == 0){
        a[i] = N - i;
      }
      int S = BIT.sum(0, p);
      if (S >= a[i]){
        int tv = p, fv = 0;
        while (tv - fv > 1){
          int mid = (tv + fv) / 2;
          if (BIT.sum(mid, p) < a[i]){
            tv = mid;
          } else {
            fv = mid;
          }
        }
        p = fv;
      } else {
        int tv = N, fv = p;
        while (tv - fv > 1){
          int mid = (tv + fv) / 2;
          if (S + BIT.sum(mid, N) < a[i]){
            tv = mid;
          } else {
            fv = mid;
          }
        }
        p = fv;
      }
    }
    BIT.add(p, -1);
    st.erase(p);
    auto itr = st.lower_bound(p);
    if (itr != st.end()){
      p = *itr;
    } else {
      p = *st.begin();
    }
  }
  for (int i = 0; i < Q; i++){
    int q;
    cin >> q;
    cout << st.count(q) << endl;
  }
}
accuracy: 1
time_ms: 140
memory_kb: 13880
final_rank: 15

code_snippet: #include <iostream>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <numeric>
using namespace std;

class LinkedList{
    public:
        long number;
        LinkedList *before, *after;

        LinkedList(long n){
            before = 0x0;
            after = 0x0;
            number = n;
        }
        LinkedList(void){
            before = 0x0;
            after = 0x0;
            number = -1;
        }
        void connect(LinkedList* l){
            after = l;
            l -> before = this;
        }
        void set(long n){
            number = n;
        }

        void print(void){
            cout<<"before pointer:\t"<<before<<endl;
            cout<<"self pointer:\t"<<this<<endl;
            cout<<"after pointer:\t"<<after<<endl;
            cout<<"value\t"<<number<<endl;
        }
};


int main(void){
    long N,M,Q;
    cin>>N>>M>>Q;
    long * a = new long[M];
    for(long i=0;i<M;i++){
        cin>>a[i];
    }
    long * q = new long[Q];
    for(long i=0;i<Q;i++){
        cin>>q[i];
    }

    LinkedList * lists = new LinkedList[N];
    lists[0].set(0);
    for(int i=1;i<N;i++){
        lists[i] = LinkedList(i);
        lists[i-1].connect(&(lists[i]));
    }
    lists[N-1].connect(&(lists[0]));

    LinkedList* index = &(lists[0]);
    
    for(long i=0;i<M;i++){
        if(a[i]%2==0){
            for(int j=0;j<a[i];j++){
                index = index -> after;
            }
        }
        else{
            for(int j=0;j<a[i];j++){
                index = index -> before;
            }
        }
        index -> before -> after = index -> after;
        index -> after -> before = index -> before;

        index = index -> after; // メモリリークしていることに注意。まあ競技プログラミングなんで...。
    }
    unordered_set<long> last_students;
    last_students.clear();
    for(int i=0;i<N-M+1;i++){
        last_students.insert(index->number);
        index = index->after;
    }

    for(long i=0;i<Q;i++){
        if(last_students.find(q[i])!=last_students.end()){
            cout<<1<<endl;
        }
        else{
            cout<<0<<endl;
        }
    }

    

    return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 9608
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
int s[200001],ss[200001],ff[200001];
int main(void)
{
	int n,m,q,a,qq,i,j,x;
	scanf("%d%d%d",&n,&m,&q);
	for(i=0;i<n;i++){
		s[i]=i+1;
		ss[i]=i-1;
		ff[i]=1;
	}
	s[n-1]=0;
	ss[0]=n-1;
	x=0;
	for(i=0;i<m;i++){
		scanf("%d",&a);
		for(j=0;j<a;j++){
			if(a%2==0) x=s[x];
			else x=ss[x];
		}
		s[ss[x]]=s[x];
		ss[s[x]]=ss[x];
		ff[x]=0;
		x=s[x];
	}
	for(i=0;i<q;i++){
		scanf("%d",&qq);
		printf("%d\n",ff[qq]);
	}
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 5456
final_rank: 4

code_snippet: #include<bits/stdc++.h>
using namespace std;
int p[200001],pp[200001],ff[200001];
int main(void)
{
	int n,m,q,a,qq,i,j,k,x;
	scanf("%d%d%d",&n,&m,&q);
	for(i=0;i<n;i++){
		pp[i]=i-1;
		p[i]=i+1;
		ff[i]=1;
	}
	p[n-1]=0;
	pp[0]=n-1;
	for(i=0;i<m;i++){
		scanf("%d",&a);
		for(j=0;j<a;j++){
			if(a%2==0) k=p[k];
			else k=pp[k];
		}
		ff[k]=0;
		pp[p[k]]=pp[k];
		p[pp[k]]=p[k];
		//printf("k=%d\n",k);
		k=p[k];
	}
	for(i=0;i<q;i++){
		scanf("%d",&qq);
		printf("%d\n",ff[qq]);
	}
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 5576
final_rank: 6

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<list>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<climits>
#include<iomanip>
#include<cctype>
#include<sstream>
#include<regex>
#include<bitset>
#include<random>
#include<complex>
using namespace std;
#define int long long
#define uint unsigned long long
const int mod=1e9+7;
const int Mod=998244353;
const int inf=mod*mod;
const double eps=1e-9;
signed main(){
	int n,m,q,a;
	cin>>n>>m>>q;
	set<int>st;
	for(int i=0;i<n;i++)
		st.insert(i);
	auto it=st.begin();
	for(int i=0;i<m;i++){
		cin>>a;
		if(a%2==0){
			for(int j=0;j<a;j++){
				it++;
				if(it==st.end())
					it=st.begin();
			}
		}else{
			for(int j=0;j<a;j++){
				if(it==st.begin())
					it=st.end();
				it--;
			}
		}
		it=st.erase(it);
		if(it==st.end())
			it=st.begin();
	}
	while(cin>>q)
		cout<<st.count(q)<<endl;
}
accuracy: 1
time_ms: 150
memory_kb: 12740
final_rank: 13