Submission #1237814

#	Time	Username	Problem	Language	Result	Execution time	Memory
1237814		Zbyszek99	Teams (IOI15_teams)	C++20	100 / 100	3214 ms	477820 KiB

teams

#include "teams.h"
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define ld long double
#define ull unsigned long long
#define ff first
#define ss second
#define pii pair<int,int>
#define pll pair<long long, long long>
#define vi vector<int>
#define vl vector<long long>
#define pb push_back
#define rep(i, b) for(int i = 0; i < (b); ++i)
#define rep2(i,a,b) for(int i = a; i <= (b); ++i)
#define rep3(i,a,b,c) for(int i = a; i <= (b); i+=c)
#define count_bits(x) __builtin_popcountll((x))
#define all(x) (x).begin(),(x).end()
#define siz(x) (int)(x).size()
#define forall(it,x) for(auto& it:(x))
using namespace __gnu_pbds;
using namespace std;
typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update> ordered_set;
//mt19937 mt;void random_start(){mt.seed(chrono::time_point_cast<chrono::milliseconds>(chrono::high_resolution_clock::now()).time_since_epoch().count());}
//ll los(ll a, ll b) {return a + (mt() % (b-a+1));}
const int INF = 1e9+50;
const ll INF_L = 1e18+40;
const ll MOD = 1e9+7;

struct seg
{
	int l,r,Y;
};

struct node
{
	int l = 0;
	int r = (1 << 19)-1;
	node* left = NULL;
	node* right = NULL;
	int sum = 0;
	int get_sum(int l2, int r2)
	{
		if(l >= l2 && r <= r2) return sum;
		if(l > r2 || r < l2) return 0;
		return (left != NULL ? left -> get_sum(l2,r2) : 0) + (right != NULL ? right -> get_sum(l2,r2) : 0);
	}
	void add(int p, node* prev)
	{
		sum = (prev != NULL ? prev -> sum : 0)+1;
		if(l == r) return;
		if(p <= (l+r)/2)
		{
			if(prev != NULL) right = prev -> right;
			left = new node;
			left -> l = l;
			left -> r = (l+r)/2;
			left -> add(p,(prev != NULL ? prev->left : NULL));
		}
		else
		{
			if(prev != NULL) left = prev -> left;
			right = new node;
			right -> l = (l+r)/2+1;
			right -> r = r;
			right -> add(p,(prev != NULL ? prev->right : NULL));
		}
	}
};

node trees[500001];
int relR[500001];

int get_sum(int lL, int rL, int lR, int rR)
{
	return trees[rL].get_sum(lR,rR) - trees[lL-1].get_sum(lR,rR);
}

void init(int n, int L[], int R[]) 
{
	vector<pii> Rs;
	rep(i,n)
	{
		Rs.pb({R[i],i});
	}
	sort(all(Rs));
	int cur_R = 0;
	int cur_Rs = 0;
	rep2(i,1,n)
	{
		relR[i] = cur_R;
		while(cur_Rs < siz(Rs) && Rs[cur_Rs].ff == i)
		{
			R[Rs[cur_Rs].ss] = cur_R++;
			cur_Rs++;
		}
	}
	vector<pii> elms;
	rep(i,n)
	{
		elms.pb({L[i],R[i]});
	}
	sort(all(elms));
	int cur_elm = 0;
	rep2(i,1,n)
	{
		vi Y;
		while(cur_elm < siz(elms) && elms[cur_elm].ff == i)
		{
			Y.pb(elms[cur_elm].ss);
			cur_elm++;
		}
		node prev = trees[i-1];
		node new_;
		forall(it,Y)
		{
			new_.add(it,&prev);
			swap(new_,prev);
		}
		trees[i] = prev;
	}
}

vector<seg> segs;
vi K;

int can(int m, int k[]) 
{
	K = {};
	segs = {};
	rep(i,m) K.pb(k[i]);
	sort(all(K));
	int prev = 0;
	forall(it,K)
	{
		int R = relR[it];
		int cur_l = prev+1;
		int cur_r = it;
		while(siz(segs) > 0)
		{
			if(segs.back().Y > R) break;
			cur_l = segs.back().l;
			segs.pop_back();
		}
		prev = it;
		if(cur_l <= cur_r)
		{
			segs.pb({cur_l,cur_r,R});
		}
		int cur_have = 0;
		while(true)
		{
			if(siz(segs) > 1 && segs.back().Y == segs[siz(segs)-2].Y)
			{
				segs.pop_back();
				segs[siz(segs)-1].r = it;
			}
			int Rbor = (siz(segs) == 1 ? (1 << 19)-1 : segs[siz(segs)-2].Y-1);
			int add = get_sum(segs.back().l,segs.back().r,segs.back().Y,Rbor);
			if(cur_have+add >= it)
			{
				int l = segs.back().Y;
				int r = Rbor;
				int ans = l;
				while(l <= r)
				{
					int mid = (l+r)/2;
					if(cur_have+get_sum(segs.back().l,segs.back().r,segs.back().Y,mid) >= it)
					{
						ans = mid;
						r = mid-1;
					} 
					else 
					{
						l = mid+1;
					}
				}
				segs[siz(segs)-1].Y = ans+1;
				break;
			}
			if(siz(segs) == 1) return 0;
			cur_have += add;
			segs.pop_back();
			segs[siz(segs)-1].r = it;
		}
	}	
	return 1;
}

• Subtask 1: 21 / 21
• Subtask 2: 13 / 13
• Subtask 3: 43 / 43
• Subtask 4: 23 / 23