【BZOJ】3616: War【KD树】

最新推荐文章于 2020-01-16 11:37:53 发布

poursoul

最新推荐文章于 2020-01-16 11:37:53 发布

阅读量1.1k

点赞数

分类专栏： K-D树

本文链接：https://blog.csdn.net/u013368721/article/details/49759669

版权

K-D树专栏收录该内容

5 篇文章 0 订阅

订阅专栏

传送门：【BZOJ】3616: War【KD树】

分析：建好树，对于每个塔，对他能打到的点打标记，这个用KD树+bitset打标记即可。所有标记打完后把标记下传，这样可以得到每个点在每一轮会被哪些塔打到，然后我们把所有同一阵营的或（位运算）起来，这样就知道每个阵营每一轮有多少的概率是完全完好的，然后pow一下累加到ans里，最后输出ans即可。复杂度 $O(N\sqrt N + \frac{N^2}{32})$

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