LibreOJ #2547.「JSOI2018」防御网络 动态规划

题意

给出一棵点仙人掌，问点集V的所有子集的斯坦纳树大小的期望是多少。取模。
$n\le200$

分析

考虑把每个点双的贡献分开算。对于一条割边，它在斯坦纳树中出现，当且仅当被它连接的两个连通块中都有点被选择。
对于一个环，设有x个点的子树中有点被选，则这x个点必须保证连通。那么我们肯定是找到距离最大的一对相邻点，然后把它们中间的边断开。
考虑枚举这个距离，设$g_i$表示有多少种选点方案满足任意一对相邻点之间的距离不小于$i$，那么相邻点之间距离的最大值为$L$的方案就是$g_L-g_{L-1}$。
考虑如何求$g_i$，枚举环上编号最小的被选择点，然后从这个点开始$dp$，设$f_i$表示$i$前面的点已处理完，且$i$一定被选的方案，用前缀和来优化转移即可。
时间复杂度是$O(n^3)$。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#include<vector>

typedef long long LL;

const int N=405;
const int MOD=1000000007;

int n,m,cnt,last[N],dep[N],fa[N],tot,bel[N],ans,a[N],b[N],size[N],f[N],g[N],bin[N],s[N];
bool vis[N];
struct edge{int to,next;}e[N*2];
std::vector<int> vec[N];

int ksm(int x,int y)
{
    int ans=1;
    while (y)
    {
        if (y&1) ans=(LL)ans*x%MOD;
        x=(LL)x*x%MOD;y>>=1;
    }
    return ans;
}

void addedge(int u,int v)
{
    e[++cnt].to=v;e[cnt].next=last[u];last[u]=cnt;
    e[++cnt].to=u;e[cnt].next=last[v];last[v]=cnt;
}

void pre(int x)
{
    vis[x]=1;dep[x]=dep[fa[x]]+1;size[x]=1;
    for (int i=last[x];i;i=e[i].next)
    {
        if (e[i].to==fa[x]) continue;
        if (!vis[e[i].to]) fa[e[i].to]=x,pre(e[i].to),size[x]+=size[e[i].to];
        else if (dep[e[i].to]<dep[x])
        {
            tot++;vec[tot].push_back(x);bel[x]=tot;
            for (int j=x;j!=e[i].to;j=fa[j]) vec[tot].push_back(fa[j]),bel[fa[j]]=tot;
        }
    }
}

int main()
{
    scanf("%d%d",&n,&m);
    bin[0]=1;
    for (int i=1;i<=n;i++) bin[i]=bin[i-1]*2%MOD;
    for (int i=1;i<=m;i++)
    {
        int x,y;scanf("%d%d",&x,&y);
        addedge(x,y);
    }
    pre(1);
    for (int i=1;i<=cnt;i+=2)
    {
        int x=e[i].to,y=e[i+1].to;
        if (dep[x]>dep[y]) std::swap(x,y);
        if (bel[x]!=bel[y]||!(bel[x]*bel[y])) (ans+=(LL)(bin[size[y]]-1)*(bin[n-size[y]]-1)%MOD)%=MOD;
    }
    for (int i=1;i<=tot;i++)
    {
        int sz=0,L=vec[i].size();
        for (int j=0;j<vec[i].size();j++) a[++sz]=vec[i][j];
        for (int j=0;j<vec[i].size();j++) a[++sz]=vec[i][j];
        for (int j=1;j<=sz;j++)
        {
            b[j]=1;
            for (int k=last[a[j]];k;k=e[k].next)
                if (bel[e[k].to]!=bel[a[j]]) b[j]+=e[k].to==fa[a[j]]?n-size[a[j]]:size[e[k].to];
        }
        memset(g,0,sizeof(g));
        for (int j=1;j<=L;j++)
        {
            for (int len=1;len<=L;len++)
            {
                memset(f,0,sizeof(f));
                memset(s,0,sizeof(s));
                f[j]=s[j]=1;
                for (int k=j+1;k<=j+L;k++)
                    if ((k-1)%L+1>=j) f[k]=(LL)(s[k-1]+MOD-s[std::max(k-len-1,0)])*(bin[b[k]]-1)%MOD,s[k]=(s[k-1]+f[k])%MOD;
                    else f[k]=0,s[k]=s[k-1];
                (g[len]+=f[j+L])%=MOD;
            }
        }
        for (int j=1;j<=L;j++) (ans+=(LL)(L-j)*(g[j]+MOD-g[j-1])%MOD)%=MOD;
    }
    printf("%d",(LL)ans*ksm(ksm(2,MOD-2),n)%MOD);
    return 0;
}