Submission #539144

#	Time	Username	Problem	Language	Result	Execution time	Memory
539144		akhan42	Hedgehog Daniyar and Algorithms (IZhO19_sortbooks)	C++17	64 / 100	2152 ms	262144 KiB

sortbooks

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

#define F first
#define S second
#define forn(i, n) for(int i = 0; i < n; ++i)
#define forbn(i, b, n) for(int i = b; i < n; ++i)
#define sz(v) (int)v.size()
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))

typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef long long ll;
typedef complex<double> cd; // !!! long double slow

template <class T> inline void mineq(T &a, T b) { a = min(a, b); }
template <class T> inline void maxeq(T &a, T b) { a = max(a, b); }


int n, q;
const int INF = 1000 * 1000 * 1000 + 10;
const int MX = 2 * 1000 * 1000;
int ol[MX], oright[MX];
bool res[MX];
vi a;


bool cmp(int v1, int v2) {
	return ol[v1] < ol[v2];
}


struct Seg {
	int mx[MX], t[MX];
	vi sl[MX];
	vector<ii> rem[MX];

	Seg(vi& a) {
		forn(i, MX)
			res[i] = true;
		for(int p = n; p < 2 * n; p++) {
			mx[p] = a[p - n];
			sl[p].pb(a[p - n]);
			t[p] = -INF;
			oright[p] = ol[p] = p - n;
		}

		for(int p = n - 1; p > 0; p--) {
			ol[p] = min(ol[2 * p], ol[2 * p + 1]);
			oright[p] = max(oright[2 * p], oright[2 * p + 1]);
			mx[p] = max(mx[2 * p], mx[2 * p + 1]);
			t[p] = max(t[2 * p], t[2 * p + 1]);
			merge(all(sl[2 * p]), all(sl[2 * p + 1]), back_inserter(sl[p]));

			int ind = lower_bound(all(sl[2 * p + 1]), mx[2 * p]) - sl[2 * p + 1].begin();
			if(ind != 0)
				maxeq(t[p], mx[2 * p] + sl[2 * p + 1][ind - 1]);
		}

		forn(i, MX)
			sl[i].clear();
	}

	void query(int l, int r, int k, int left_max, int qid) {
		vi vert;
		for (l += n, r += n + 1; l < r; l >>= 1, r >>= 1) {
			if (l & 1) {
				vert.pb(l++);
			}
			if (r & 1) {
				vert.pb(--r);
			}
		}
		sort(all(vert), cmp);

		bool ans = true;
		for(int v: vert) {
			ans = ans && t[v] <= k;
			int rp = left_max - 1, lp = k - left_max + 1;

			if(lp <= rp) {
				rem[v].pb({lp - 1, qid});
				rem[v].pb({rp, qid});
			}

			maxeq(left_max, mx[v]);
		}

		res[qid] = ans;
	}

	void process() {
		for(int v = 1; v < 2 * n; v++) {
			sort(all(rem[v]));
			vi slv;
			for(int j = ol[v]; j <= oright[v]; j++)
				slv.pb(a[j]);
			sort(all(slv));

			set<int> act;
			int i = 0;

			for(ii p: rem[v]) {
				int qid = p.S;
				if(res[qid] == false)
					continue;
				int en = p.F;

				if(i < sz(slv) && slv[i] <= en) {
					for(int qid_act: act) {
						res[qid_act] = false;
					}
					act.clear();
				}
				while(i < sz(slv) && slv[i] <= en)
					i += 1;

				if(act.find(qid) == act.end()) {
					act.insert(qid);
				}
				else {
					act.erase(qid);
				}
			}

			rem[v].clear();
		}
	}
};



void solve() {
	cin >> n >> q;
	a.resize(n);
	forn(i, n)
		cin >> a[i];

	Seg seg(a);
	int qq = q / 4;

	forn(qid, q) {
		int l, r, k;
		cin >> l >> r >> k;
		l--; r--;

		seg.query(l, r, k, -INF, qid);

		if(qid == qq || qid == 2 * qq || qid == 3 * qq) {
			seg.process();
		}
	}

	seg.process();

	forn(qid, q) {
		cout << res[qid] << '\n';
	}
}


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

//	freopen("boards.in", "r", stdin);
//	freopen("boards.out", "w", stdout);

    int t = 1;
//  cin >> t;
    while(t--) {
        solve();
    }
}

• Subtask 1: 8 / 8
• Subtask 2: 9 / 9
• Subtask 3: 0 / 13
• Subtask 4: 17 / 17
• Subtask 5: 30 / 30
• Subtask 6: 0 / 23