bzoj4374 Little Elephant and Boxes【动态规划+折半搜索】

解题思路：

开始以为直接求出期望得到的钱和钻石数，再背包dp一波就行了，但看了答案不是整数就知道不行了。还是要根据期望的定义，列出所有方案求解才行。

但直接求出所有方案是不现实的，看了n=30，应该是折半搜索。
所以我们先固定一维，用f[i][j][k]表示前i个物品取j个，花了k个钻石所消耗的最小钱数，这个很容易dp求出，可以见代码。

再折半搜索，分别取第1~n/2,第n/2+1~n个盒子，把两边的方案得到的钱数按取得的钻石数分组。
最后枚举左边花费的钻石数，右边花费的方案数，就可以得到p[j]表示至少取j个物品的概率，然后统计答案即可。

如有不清楚的可以看一下代码，还是很好懂的。

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

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=35,INF=0x3f3f3f3f;
int T,n,m,lim,f[N][N][N],ca[N],cb[N];
double p[N],ans;
struct node1{int x;double p;}a[N],A[N][33000],B[N][33000];
struct node2{int c,d;}b[N];
inline bool cmp(const node1 &a,const node1 &b){return a.x<b.x;}

void dfsl(int x,int y,int c,double p)
{
    if(x==lim+1)
    {
        A[y][++ca[y]].x=c,A[y][ca[y]].p=p;
        return;
    }
    dfsl(x+1,y,c+a[x].x,p*a[x].p);
    dfsl(x+1,y+1,c,p*(1-a[x].p));
}

void dfsr(int x,int y,int c,double p)
{
    if(x==n+1)
    {
        B[y][++cb[y]].x=c,B[y][cb[y]].p=p;
        return;
    }
    dfsr(x+1,y,c+a[x].x,p*a[x].p);
    dfsr(x+1,y+1,c,p*(1-a[x].p));
}

double calc(int x,int y,int z)
{
    if(z==INF||!ca[x]||!cb[y])return 0;
    int n=ca[x],m=cb[y];double res=0,p=0;
    for(int i=1;i<=n;i++)
    {
        while(m&&A[x][i].x+B[y][m].x>=z)p+=B[y][m--].p;
        res+=A[x][i].p*p;
    }
    return res;
}

int main()
{
    //freopen("lx.in","r",stdin);
    T=getint();
    while(T--)
    {
        n=getint(),m=getint(),lim=n/2;
        for(int i=1;i<=n;i++)a[i].x=getint(),a[i].p=getint()*0.01;
        for(int i=1;i<=m;i++)b[i].c=getint(),b[i].d=getint();
        memset(f,INF,sizeof(f));
        f[0][0][0]=0;
        for(int i=1;i<=m;i++)
            for(int j=0;j<=m;j++)
                for(int k=0;k<=n;k++)
                    if(f[i-1][j][k]<INF)
                    {
                        f[i][j][k]=min(f[i][j][k],f[i-1][j][k]);
                        if(k+b[i].d<=n)f[i][j+1][k+b[i].d]=min(f[i][j+1][k+b[i].d],f[i-1][j][k]+b[i].c);
                    }
        for(int j=0;j<=m;j++)for(int k=1;k<=n;k++)f[m][j][k]=min(f[m][j][k],f[m][j][k-1]);
        memset(ca,0,sizeof(ca));memset(cb,0,sizeof(cb));
        dfsl(1,0,0,1),dfsr(lim+1,0,0,1);
        for(int i=0;i<=n;i++)
        {
            if(ca[i])sort(A[i]+1,A[i]+ca[i]+1,cmp);
            if(cb[i])sort(B[i]+1,B[i]+cb[i]+1,cmp);
        }
        ans=0;
        memset(p,0,sizeof(p));
        for(int i=m;i;i--)
        {
            for(int j=0;j<=n;j++)
                for(int k=0;k<=j&&k<=lim;k++)
                    p[i]+=calc(k,j-k,f[m][i][j]);
            ans+=(p[i]-p[i+1])*i;
        }
        printf("%.4f\n",ans);
    }
}