2018景驰科技杯 A 欧洲爆破 DFS+概率DP+逆元

“景驰科技杯”2018年华南理工大学程序设计竞赛 A题

题目链接：

https://www.nowcoder.com/acm/contest/94/A

题意：

n个炸弹 n<=20

每个炸弹有坐标Xi Yi跟波及范围Ri，Ri内未引爆的炸弹也会爆（即有可能会多重连锁爆炸www）

每次选一个炸弹引爆

问炸弹全部爆炸的期望次数

思路：

跟hdu4336其实差不多

炸弹状态压缩

设E【S】为当前已引爆S状态的炸弹 还需要的期望次数

那么E【S】=E【S】*p（S的第j位为1）+sum（pj*E【S|fuck( j )】））（S的第j位为0）+1

边界E【111111....】=0，答案就是E【0】

fuck(j)是指引爆第j个炸弹后的炸弹状态（包括多重连锁爆炸）

其实就是枚举后继w

那么我们先搜索维护出fuck（i），然后跑一遍就好了

（这个搜索写错无数遍QAQ）

由于答案分数要求逆元：x/y=x*invy，所以先预处理0~30的逆元

（不预处理就T了QAQ）

复杂度O（n*2^n） 536ms

（这种记忆化搜索写能更快？？？）

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<string.h>
using namespace std;
const int mod=1e9+9;
#define ll long long
struct node{
    ll x,y,r;
    node(){ };
    node(ll x,ll y,ll r):x(x),y(y),r(r){};
}po[35];
ll fuck[35];
ll E[(1<<20)+1];
ll inv2[35];
bool vis[35];
int cnt=0;
ll inv(ll t, ll p) {
    return t == 1 ? 1 : (p - p / t) * inv(p % t, p) % p;
}
 
ll dis(node a,node b){
    return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
 ll diu=0;
void dfs(int x,int n)
{
	vis[x]=1;
    for(int i=1;i<=n;i++)
    {
        if(i==x||vis[i])continue;
        if(dis(po[x],po[i])-po[x].r*po[x].r<=0)
        {
            diu|=1<<(i-1);
            dfs(i,n);
        }
    }
     
}
int main()
{
    ll n;
    inv2[0]=0; inv2[1]=1;
    for(int i=2;i<=30;i++)
    	inv2[i]=inv(i,mod);
    while(~scanf("%lld",&n))
    {
        memset(E,0,sizeof(E));
        memset(fuck,0,sizeof(fuck));
        for(int i=1;i<=n;i++)
            scanf("%lld %lld %lld",&po[i].x,&po[i].y,&po[i].r);
        for(int i=1;i<=n;i++)
        {
        	diu=1<<(i-1);memset(vis,0,sizeof(vis));
            dfs(i,n);//这个搜索一直写错 
            fuck[i]=diu;
        }
    //  for(int i=1;i<=n;i++)
    //     printf("%d\n",fuck[i]);
    //  double pp=1.0/n;
        E[(1<<n)-1]=0;
       // E(11111)://E(i)当前i中的1代表已经被引爆的状态，还需要的次数的期望  枚举后继 
        for(int i=(1<<n)-2;i>=0;i--)
        {
            ll num=0;ll t=0;
            for(int j=0;j<n;j++)
            {
                if((1<<j)&i)  num++;//不能写成i|fuck[j+1]!=0 
                else
                {
                    t+=E[i|fuck[j+1]];
                    t=(t+mod)%mod;
                }
            }
            E[i]=1ll*((t+n+mod)%mod)*inv2[n-num]%mod;//不预处理T了 QAQ 
            E[i]%=mod;
        }
        printf("%d\n",E[0]%mod);
    }
}