【BZOJ4899】记忆的轮廓-期望DP+决策单调性优化DP

测试地址:记忆的轮廓
做法:本题需要用到期望DP+决策单调性优化DP。
f(i,j)为前i个点用了j个存档点,其中第j个存档点用在第i个点上的最小期望步数,我们显然可以得出状态转移方程:
f(i,j)=min{f(k,j1)+g(k,j)}
其中g(k,j)表示在第k个点存档,然后在不存其他档的情况下走到第j个点的期望步数。显然我们要先预处理出来这个东西才能DP。
首先考虑一个点能走到的所有错误节点,令s(i)为从错误节点i一条路走到黑,回到存档点的期望步数,那么叶子节点的s(i)=1,而其他错误节点的s(i)=1+1deg(i)vs(v),其中deg(i)指它能走到的点数,v是它能走到的点。于是我们有:
g(i,j+1)=g(i,j)+1+1deg(j)vs(v)
这个式子的意义是,要走到j+1,首先得走到j,然后走一步,这一步有可能走到j+1,也有可能误入歧途,要重新走回存档点,再从存档点走到j+1。移项得:
g(i,j+1)=deg(j)g(i,j)+deg(j)+vs(v)
于是我们就可以O(n2)预处理出g了。
再回到求f的式子,我们发现这是一个O(n3)的式子,直接求解会TLE。注意到把j一维去掉后,它就是一个标准的1D/1D状态转移方程,于是我们思考能不能证明决策单调性,即证明g(i,j+1)g(i,j)g(i+1,j+1)g(i+1,j)
先考虑左边,把g(i,j+1)按状态转移方程展开,左边就等于(deg(j)1)g(i,j)加一些东西,而右边相似地展开成(deg(j)1)g(i+1,j)加一些东西,后面那一串相同,而显然g(i,j)g(i+1,j),且deg(j)1,所以上面的不等式得证,于是这个方程满足决策单调性。
知道了这一点之后,直接用模板优化成O(pnlogn)即可。
以下是本人代码:

#include <bits/stdc++.h>
using namespace std;
const double eps=1e-7;
int T,n,m,p,first[2010]={0},tot=0;
double deg[2010],f[2010][2010],g[2010][2010],step[2010]={0};
int q[2010],l[2010],r[2010];
struct edge
{
    int v,next;
}e[2010];

void insert(int a,int b)
{
    e[++tot].v=b;
    e[tot].next=first[a];
    first[a]=tot;
}

void dp(int v)
{
    deg[v]=step[v]=0.0;
    for(int i=first[v];i;i=e[i].next)
    {
        dp(e[i].v);
        deg[v]+=1.0;
        step[v]+=step[e[i].v];
    }
    if (deg[v]>0.5) step[v]/=deg[v];
    step[v]+=1.0;
}

double calc(int l,int r,int k)
{
    return f[l][k]+g[l][r];
}

int solve(int k,int l,int r,int i,int j)
{
    r++;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if (calc(k,mid,j-1)+eps>calc(i,mid,j-1))
            r=mid;
        else l=mid+1;
    }
    return l;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&p);
        memset(first,0,sizeof(first));
        tot=0;
        for(int i=1;i<=m-n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            insert(a,b);
        }

        for(int i=1;i<=n;i++)
        {
            deg[i]=step[i]=0.0;
            for(int j=first[i];j;j=e[j].next)
                if (e[j].v>n)
                {
                    deg[i]+=1.0;
                    dp(e[j].v);
                    step[i]+=step[e[j].v];
                }
            deg[i]+=1.0;
        }

        for(int i=1;i<=n;i++)
        {
            g[i][i]=0.0;
            for(int j=i+1;j<=n;j++)
                g[i][j]=deg[j-1]*g[i][j-1]+deg[j-1]+step[j-1];
        }

        for(int i=1;i<=n;i++)
            f[i][1]=g[1][i];
        for(int j=2;j<p;j++)
        {
            int h=1,t=1;
            q[h]=1,l[h]=1,r[h]=n;
            for(int i=1;i<=n;i++)
            {
                if (i==42)
                    t++,t--;
                f[i][j]=calc(q[h],i,j-1);
                l[h]++;
                if (h<=t&&r[h]<l[h]) h++;
                if (h>t||calc(q[t],n,j-1)+eps>calc(i,n,j-1))
                {
                    while(h<=t&&calc(q[t],l[t],j-1)+eps>calc(i,l[t],j-1)) t--;
                    if (h>t) q[++t]=i,l[t]=i+1,r[t]=n;
                    else
                    {
                        int tmp=solve(q[t],l[t],r[t],i,j);
                        r[t]=tmp-1;
                        q[++t]=i,l[t]=tmp,r[t]=n;
                    }
                }
            }
        }
        printf("%.4lf\n",f[n][p-1]);
    }

    return 0;
}
posted @ 2018-06-29 17:52  Maxwei_wzj  阅读(189)  评论(0编辑  收藏  举报