分析:建好树,对于每个塔,对他能打到的点打标记,这个用KD树+bitset打标记即可。所有标记打完后把标记下传,这样可以得到每个点在每一轮会被哪些塔打到,然后我们把所有同一阵营的或(位运算)起来,这样就知道每个阵营每一轮有多少的概率是完全完好的,然后pow一下累加到ans里,最后输出ans即可。复杂度 O(NN−−√+N232)
my code:
#include <bits/stdc++.h>
using namespace std ;
typedef long long LL ;
const int MAXN = 35005 ;
const int MAXE = 10000005 ;
struct Edge {
int v , n ;
Edge () {}
Edge ( int v , int n ) : v ( v ) , n ( n ) {}
} ;
struct Node {
int p[2] ;
int f , l , r ;
int Min[2] , Max[2] ;
int operator [] ( const int& idx ) const {
return p[idx] ;
}
void input ( int idx ) {
scanf ( "%d%d" , &p[0] , &p[1] ) ;
f = idx ;
}
void up ( Node& a ) {
Min[0] = min ( Min[0] , a.Min[0] ) ;
Max[0] = max ( Max[0] , a.Max[0] ) ;
Min[1] = min ( Min[1] , a.Min[1] ) ;
Max[1] = max ( Max[1] , a.Max[1] ) ;
}
} ;
Node T[MAXN] ;
Edge E[MAXE] ;
int H[MAXN] , cntE ;
int idx[MAXN] , cmpw , root ;
int a[MAXN] , r[MAXN] , belong[MAXN] ;
int n , m , k ;
bitset < MAXN > G[MAXN] ;
vector < int > B[MAXN] ;
void addedge ( int u , int v ) {
E[cntE] = Edge ( v , H[u] ) ;
H[u] = cntE ++ ;
}
bool cmp ( const Node& a , const Node& b ) {
return a[cmpw] < b[cmpw] ;
}
void up ( int o ) {
if ( T[o].l ) T[o].up ( T[T[o].l] ) ;
if ( T[o].r ) T[o].up ( T[T[o].r] ) ;
}
int build ( int l , int r , int w , int f ) {
int mid = l + r >> 1 ;
cmpw = w ;
nth_element ( T + l , T + mid , T + r + 1 , cmp ) ;
idx[T[mid].f] = mid ;
T[mid].f = f ;
T[mid].Min[0] = T[mid].Max[0] = T[mid][0] ;
T[mid].Min[1] = T[mid].Max[1] = T[mid][1] ;
T[mid].l = l != mid ? build ( l , mid - 1 , !w , mid ) : 0 ;
T[mid].r = r != mid ? build ( mid + 1 , r , !w , mid ) : 0 ;
up ( mid ) ;
return mid ;
}
int sqr ( int x ) {
return x * x ;
}
int check1 ( Node& a , int x , int y , int r ) {
int d1 = sqr ( max ( max ( x - a.Max[0] , a.Min[0] - x ) , 0 ) ) + sqr ( max ( max ( y - a.Max[1] , a.Min[1] - y ) , 0 ) ) <= r * r ;
int d2 = max ( sqr ( x - a.Min[0] ) , sqr ( x - a.Max[0] ) ) + max ( sqr ( y - a.Min[1] ) , sqr ( y - a.Max[1] ) ) <= r * r ;
if ( d1 && d2 ) return 1 ;//in
if ( d1 ) return 2 ;//cross
return 0 ;//ou
}
int check2 ( Node& a , int x , int y , int d ) {
int d1 = max ( a.Min[0] - x , 0 ) + max ( x - a.Max[0] , 0 ) + max ( a.Min[1] - y , 0 ) + max ( y - a.Max[1] , 0 ) <= d ;
int d2 = max ( abs ( a.Min[0] - x ) , abs ( x - a.Max[0] ) ) + max ( abs ( a.Min[1] - y ) , abs ( y - a.Max[1] ) ) <= d ;
if ( d1 && d2 ) return 1 ;//in
if ( d1 ) return 2 ;//cross
return 0 ;//ou
}
void upd ( int o , int id , int x , int y ) {
int d1 = check1 ( T[o] , x , y , r[id] ) ;
if ( d1 == 1 ) {
G[o][id] = 1 ;
return ;
}
int d2 = check2 ( T[o] , x , y , a[id] ) ;
if ( d2 == 1 ) {
G[o][id] = 1 ;
return ;
}
if ( d1 == 0 && d2 == 0 ) return ;
if ( sqr ( T[o][0] - x ) + sqr ( T[o][1] - y ) <= r[id] * r[id] ) addedge ( o , id ) ;
else if ( abs ( T[o][0] - x ) + abs ( T[o][1] - y ) <= a[id] ) addedge ( o , id ) ;
if ( T[o].l ) upd ( T[o].l , id , x , y ) ;
if ( T[o].r ) upd ( T[o].r , id , x , y ) ;
}
void down ( int o ) {
if ( T[o].l ) {
G[T[o].l] |= G[o] ;
down ( T[o].l ) ;
}
if ( T[o].r ) {
G[T[o].r] |= G[o] ;
down ( T[o].r ) ;
}
for ( int i = H[o] ; i ; i = E[i].n ) {
G[o][E[i].v] = 1 ;
}
}
void solve () {
cntE = 1 ;
for ( int i = 1 ; i <= n ; ++ i ) {
T[i].input ( i ) ;
scanf ( "%d%d%d" , &r[i] , &a[i] , &belong[i] ) ;
B[belong[i]].push_back ( i ) ;
}
root = build ( 1 , n , 0 , 0 ) ;
for ( int i = 1 ; i <= n ; ++ i ) {
int x = T[idx[i]][0] , y = T[idx[i]][1] ;
upd ( root , i , x , y ) ;
}
down ( root ) ;
double ans = 0 ;
for ( int i = 1 ; i <= k ; ++ i ) {
bitset < MAXN > tmp ;
tmp.reset () ;
for ( int j = 0 ; j < B[i].size () ; ++ j ) {
tmp |= G[idx[B[i][j]]] ;
}
for ( int j = 0 ; j < B[i].size () ; ++ j ) {
tmp[B[i][j]] = 0 ;
}
int num = tmp.count () ;
ans += pow ( 1 - 1.0 * num / n , m ) ;
}
printf ( "%.5f\n" , ans ) ;
}
int main () {
scanf ( "%d%d%d" , &n , &m , &k ) ;
solve () ;
return 0 ;
}