Submission #1237811

#	Time	Username	Problem	Language	Result	Execution time	Memory
1237811		Zbyszek99	Teams (IOI15_teams)	C++20	77 / 100	2916 ms	562556 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;
	node* right;
	int sum = 0;
	bool was = 0;
	void upd()
	{
		if(!was)
		{
			left = new node;
			left -> l = l;
			left -> r = (l+r)/2;
			right = new node;
			right -> l = (l+r)/2+1;
			right -> r = r;
		}
		was = 1;
	}
	int get_sum(int l2, int r2)
	{
		if(l >= l2 && r <= r2) return sum;
		if(l > r2 || r < l2) return 0;
		upd();
		return left -> get_sum(l2,r2) + right -> get_sum(l2,r2);
	}
	void add(int p, node* prev)
	{
		sum = prev -> sum+1;
		if(l == r) return;
		was = 1;
		prev -> upd();
		if(p <= (l+r)/2)
		{
			right = prev -> right;
			left = new node;
			left -> l = l;
			left -> r = (l+r)/2;
			left -> add(p,prev->left);
		}
		else
		{
			left = prev -> left;
			right = new node;
			right -> l = (l+r)/2+1;
			right -> r = r;
			right -> add(p,prev->right);
		}
	}
};

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;
	}
}

int can(int m, int k[]) 
{
	vi K;
	rep(i,m) K.pb(k[i]);
	sort(all(K));
	int prev = 0;
	vector<seg> segs;
	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: 0 / 23