Submission #605248

#	Time	Username	Problem	Language	Result	Execution time	Memory
605248		l_reho	Event Hopping (BOI22_events)	C++14	10 / 100	1596 ms	12828 KiB

events

#include<bits/stdc++.h>
using namespace std;
 
#define ll long long

int N, Q;
vector<ll> S, E;
vector<array<ll, 3>> ranges;

vector<ll> M;

void build(int p, int L, int R){
	
	if(L == R){
		M[p] = ranges[L][0];
		return;
	}
	
	int mid = (L+R)/2;
	build(p*2, L, mid);
	build(p*2+1, mid+1, R);
	
	M[p] = min(M[p*2], M[p*2+1]);
	
}

int findLeftMostGood(int p, int L, int R, int l, int v){
	
	if(R < l) return -1;
	
	if(L >= l) {
		if(M[p] > v) return -1;
		
		
		int low = L;
		int high = R;
		int pp = p;
		while(low < high){
			int mid = low + (high-low)/2;
			
			if(M[pp*2] <= v){
				high = mid;
				pp*=2;
			}else{
				low = mid+1;
				pp=pp*2+1;
			}
		}
		
		return low;
	}
	
	
	int mid = (L+R)/2;
	int ret1 = findLeftMostGood(p*2, L, mid, l, v);
	if(ret1 != -1) return ret1;
	
	return findLeftMostGood(p*2+1, mid+1, R, l, v);
	
}

int findTheFirstSmallerThan(int v){
	
	int low = 0;
	int high = N-1;
	
	int idx = -1;
	while(low < high){
		int mid = low + (high-low)/2;
		
		if(ranges[mid][1] > v){
			low = mid+1;
			
		}else{
			idx = mid;
			high = mid;
			
		}
	}
	
	
	return idx;
}

void solve(){
	cin>>N>>Q;
	
	S.assign(N, 0);
	E.assign(N, 0);
	M.assign(4*N+1, 0);
	ranges.assign(N, array<ll, 3>());
	// graph.assign(N, vector<int>());
	
	
	for(int i = 0; i < N; i++){
		int s, e;
		cin>>s>>e;
		
		S[i] = s;
		E[i] = e;
		
		ranges[i] = {s, e, i};
	}
	map<int, int> mp;
	sort(ranges.begin(), ranges.end(), [&](array<ll, 3> a, array<ll, 3> b){
		return a[1] > b[1] || (a[1] == b[1] && a[0] > b[0]);
	});
	
	for(int i = 0; i < N; i++) {
		mp[ranges[i][2]] = i;
	}
	build(1, 0, N-1);
	
	for(int q = 0; q < Q; q++){
		int sq, eq;
		cin>>sq>>eq;
		sq--;
		eq--;
		
		queue<int> que;
		que.push(sq);
		
		vector<ll> dist(N, LLONG_MAX);
		
		dist[sq] = 0;
		while(!que.empty()){
			int curr = que.front();
			
			que.pop();
			
			int node = (dist[eq] == LLONG_MAX && S[eq] <= E[curr] && E[eq] >= E[curr]) ? eq : -1;
			
			if(node == -1){
			
				// segment tree + lower_bound
				
				// int L = findTheFirstSmallerThan(E[eq]);
				int idx = findLeftMostGood(1, 0, N-1, mp[eq], E[curr]);	
				if(idx != -1 && ranges[idx][0] <= E[curr] && ranges[idx][1] >= E[curr] && ranges[idx][1] <= E[eq])
					node = ranges[idx][2];
				
				/*
				for(int j = 0; j < N; j++){
					if(dist[ranges[j][2]] == LLONG_MAX &&  ranges[j][0] <= E[curr] && ranges[j][1] >= E[curr] && ranges[j][1] <= E[eq]) {
						node = ranges[j][2];
						break;
					}
				}
				*/
				
			}
			
			
			if(node != -1 && node != curr){
				dist[node] = dist[curr] +1;
				que.push(node);
			}
			
			/*
			for(int a : adj){
				if(dist[sq][a] != INT_MAX) continue;
				
				dist[sq][a] = dist[sq][curr]+1;
				que.push(a);
			}
			*/
		}
		if(dist[eq] == LLONG_MAX)
			cout<<"impossible"<<endl;
		else cout<<dist[eq]<<endl;
		
	}
	
	
}
 
int main(){
	solve();
	return 0;
}

• Subtask 1: 0 / 10
• Subtask 2: 10 / 10
• Subtask 3: 0 / 15
• Subtask 4: 0 / 15
• Subtask 5: 0 / 20
• Subtask 6: 0 / 30