제출 #514937

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
514937		AugustinasJucas	원 고르기 (APIO18_circle_selection)	C++14	37 / 100	3123 ms	899228 KiB

circle_selection

#include <bits/stdc++.h>
using namespace std;
const long long inf = 2.1e9 + 1;
const long long dydis = (3e5+1);
const int dd = 21;
int n, m, v, ind;
long long x, y, kur, R;
int dbInd = 0;
int mInd[dd] = {};
vector<int> allX;
vector<int> l, r, ml, mr;
vector<long long> treeVals[dd];
vector<vector<long long> > base;
vector<pair<pair<int, int>, pair<int, long long> > > mas;
bitset<dydis> circleRemoved;
bitset<(4 * dydis)> removed[dd];
vector<pair<int, int> > kurYra[dydis];
vector<int> rightmost[dd];
vector<int> sz[dd];
vector<int> tevas[dd];
int by[dydis];
vector<int> unique(vector<int> &a) {
	vector<int> ret;
	sort(a.begin(), a.end());
	for(auto &x : a){
		if(ret.size() == 0 || ret.back() != x) ret.push_back(x); 
	}
	return ret;
}
int m1, m2;
int h[dydis * 4];
void build(int v, int he = 0) {
	h[v] = he;
	if(v >= m){
		l[v] = r[v] = dbInd++;
		ml[v] = mInd[he];
		for(auto &x : base[l[v]]) {
			treeVals[he][mInd[he]++] = x;
		}
		mr[v] = mInd[he]-1;
	}else {
		build(v*2, he+1);
		build(v*2+1, he+1);
		
		l[v] = l[v*2];
		r[v] = r[v*2+1];
		ml[v] = mInd[he];
		
		m1 = ml[v*2];
		m2 = ml[v*2+1];
		while(true) {
			if(m1 == mr[v*2]+1 && m2 == mr[v*2+1]+1) break;
			if(m1 == mr[v*2]+1) {
				treeVals[he][mInd[he]++] = treeVals[he+1][m2++];
			}else if(m2 == mr[v*2+1]+1){
				treeVals[he][mInd[he]++] = treeVals[he+1][m1++];
			}else if(treeVals[he+1][m1] <= treeVals[he+1][m2]){
				treeVals[he][mInd[he]++] = treeVals[he+1][m1++];
			}else {
				treeVals[he][mInd[he]++] = treeVals[he+1][m2++];
			}
		}
		mr[v] = mInd[he]-1;
	}
	for(int i = ml[v]; i <= mr[v]; i++) {
		kurYra[treeVals[he][i]%dydis].push_back({v, i});
	}
}
int vec[dydis]; 
int id = 0, ret;
int fP(int v, int he) {
	id = 0;
	while(true) {
		vec[id++] = v;
		ret = v;
		if(tevas[he][v] == v) break;
		v = tevas[he][v];
	}
	for(int i = 0; i < id; i++) tevas[he][vec[i]] = ret;
	return ret;
}
void conn(int a, int b, int he) {
	a = fP(a, he);
	b = fP(b, he);
	if(sz[he][a] < sz[he][b]) swap(a, b); 
	tevas[he][b] = a;
	sz[he][a] += sz[he][b];
	rightmost[he][a] = max(rightmost[he][a], rightmost[he][b]);
}
void remove(int ind){
	if(circleRemoved[ind]) return ;
	circleRemoved[ind] = 1;
	int i;
	for(auto &x : kurYra[ind]) {
		v = x.first;
		i = x.second;
		removed[h[v]][i] = 1;
		if(i-1 >= ml[v] && removed[h[v]][i-1]) {
			conn(i-1, i, h[v]);
		}
		if(i+1 <= mr[v] && removed[h[v]][i+1]) {
			conn(i+1, i, h[v]);
		}
	}
}
/*
void print(int v) {
	if(v < m){
		print(v*2);
		print(v*2+1);
	}
	cout << "v = " << v << ", [" << l[v] << "; " << r[v] << "], atitinkamas masyvas: ["; 
	for(int i = ml[v]; i <= mr[v]; i++) {
		if(removed[i]) continue;
		cout << "(y=" << treeVals[i]/dydis << ", i=" << treeVals[i]%dydis << ")";
		if(i != mr[v]) cout << ", ";
	}
	cout << "]\n";
}*/
long long X1, Y1, R1, X2, Y2, R2;
bool kertasi (int i, int j) {
	X1 = mas[i].second.first; Y1 = mas[i].second.second; R1 = mas[i].first.first;
	X2 = mas[j].second.first; Y2 = mas[j].second.second; R2 = mas[j].first.first;
	return (X1 - X2) * (X1 - X2) + (Y1 - Y2) * (Y1 - Y2) <= (R1 + R2) * (R1 + R2);
}
int beg;
bitset<dydis> selected;
int selList[dydis];
int selInd = 0;
void find(int v, int L, int R, long long down, long long up){
	if(L <= l[v] && r[v] <= R) {
		beg = lower_bound(treeVals[h[v]].begin() + ml[v], treeVals[h[v]].begin() + mr[v] + 1, 1ll * down * dydis) - treeVals[h[v]].begin();
		for(int i = beg; i <= mr[v]; i++) {
			if(treeVals[h[v]][i] / dydis > up) break;
			if(removed[h[v]][i]) {
				i = rightmost[h[v]][fP(i, h[v])];
				continue;
			}
			if(!selected[treeVals[h[v]][i]%dydis]) {
				selected[treeVals[h[v]][i]%dydis] = 1;
				selList[selInd++] = treeVals[h[v]][i]%dydis;
			}
		}
		
	}else if(r[v] < L || R < l[v]) {
		
	}else{
		find(v*2, L, R, down, up);
		find(v*2+1, L, R, down, up);
	}
}
int main(){
	cin.tie(NULL);
	ios_base::sync_with_stdio(false);
	
	l.resize(4 * dydis);
	r.resize(4 * dydis);
	ml.resize(4 * dydis);
	mr.resize(4 * dydis);
	for(int i = 0; i < dd; i++){
		rightmost[i].resize(4*dydis);
		treeVals[i].resize(4*dydis);
		sz[i].resize(4*dydis);
		tevas[i].resize(4*dydis);
	}
	for(int j = 0; j < dd; j++){
		for(int i = 0; i < (int) tevas[j].size(); i++) {
			tevas[j][i] = i;
			sz[j][i] = 1;
			rightmost[j][i] = i;
		}
	}
	cin >> n;
	for(int i = 0; i < n; i++) {
		cin >> x >> y >> R;
		y += inf;
		mas.push_back({{R, -i}, {x, y}});
	}
		
	sort(mas.begin(), mas.end());
	reverse(mas.begin(), mas.end());
	for(auto &x : mas) x.first.second *= -1;
	
	for(int i = 0; i < n; i++) {
		allX.push_back(mas[i].second.first-mas[i].first.first);
		allX.push_back(mas[i].second.first+mas[i].first.first);
	}
	allX = unique(allX);
	base.resize(allX.size());
	m = allX.size();
	
	for(int i = 0; i < n; i++) {
		x = mas[i].second.first;
		y = mas[i].second.second;
		R = mas[i].first.first;
		
		kur = lower_bound(allX.begin(), allX.end(), x+R) - allX.begin();
		base[kur].push_back(1ll*(y-R)*dydis + i);
		base[kur].push_back(1ll*(y+R)*dydis + i);
		
		kur = lower_bound(allX.begin(), allX.end(), x-R) - allX.begin();
		base[kur].push_back(1ll*(y-R)*dydis + i);
		base[kur].push_back(1ll*(y+R)*dydis + i);
	}
	
	for(auto &x : base) sort(x.begin(), x.end());
	
	build(1);
	long long L, R, ll, rr;
	for(int i = 0; i < n; i++) {
		if(circleRemoved[i]) continue;
		L = mas[i].second.first - mas[i].first.first;
		R = mas[i].second.first + mas[i].first.first;
		ll = lower_bound(allX.begin(), allX.end(), L) - allX.begin();
		rr = lower_bound(allX.begin(), allX.end(), R) - allX.begin();
		selInd = 0;
		find(1, ll, rr, mas[i].second.second - mas[i].first.first, mas[i].second.second + mas[i].first.first);
		for(int j = 0; j < selInd; j++){
			selected[selList[j]] = 0;
			if(!kertasi(i, selList[j])) continue;
			remove(selList[j]);
			by[mas[selList[j]].first.second] = mas[i].first.second;
		}
	}
	for(int i = 0; i < n; i++) {
		cout << by[i] + 1 << " ";
	}
	return 0;
}
/*
5
0 0 3
5 -2 2
5 0 1
1 1 1
1 -3 1

 11
9 9 2
13 2 1
11 8 2
3 3 2
3 12 1
12 14 1
9 8 5
2 8 2
5 2 1
14 4 2
14 14 1 
 
 

*/

• Subtask 1: 7 / 7
• Subtask 2: 0 / 12
• Subtask 3: 0 / 15
• Subtask 4: 0 / 23
• Subtask 5: 30 / 30
• Subtask 6: 0 / 13