BZOJ 4899 记忆的轮廓

话说BZOJ 是不是死了啊

（已经没有传送门了）

设 $f[i][j]$ 表示走到第 $j$ 个位置确定了 $i$ 个存档点时的最小代价，并强制第 $j$ 个位置有一个存档点

那么设 $cst[i][j]$ 表示存档点在 $i$ ，走到位置 $j$ 的代价， $f$ 有转移：

$f[i][j]=f[i-1][k]+cst[k][j]$

考虑 $cst[i][j]$ 如何计算，对每个起点 $i$ 求出 $i$ 指向的错误节点 $v$ 重新走回 $i$ 的期望步数 $dis[v]$，这个可以简单树形 $dp$ 得到

那么设 $val=\sum_{v \in son(j-1)} (cst[i][j-1]+1+dis[v])$ ，那么有 $cst[i][j]=cst[i][j-1]+1+val$

这里 $val$ 意义显然为从 $j-1$ 走到 $j$ 的期望代价，因为从 $j-1$ 到各个后继的概率一样，所以期望就是把每个后继各走一遍

加上 $cst[i][j-1]+1$ 显然是因为存档点在 $i$ ，要走到 $j-1$ 的后面一个儿子代价就是 $cst[i][j-1]+1$

然后这样就可以 $n^3$ 跑 $dp$ 了，考虑如何优化

把 $cst$ 的表打出来发现 $cst[i][j]$ 比 $cst[i][j-1]$ 的值大很多，发现 $cst$ 增长很快，显然超过一次函数

那么对于 $a<b<c<d$ ，就有 $cst[a][c]+cst[b][d]<=cst[a][d]+cst[b][c]$，即满足四边形不等式

所以对于 $f[i][j]$ 的最优转移点 $k$ ，$f[i][j+1]$ 的最优转移点一定不小于 $k$（不然我们直接从 $f[i-1][k]$ 转移会更优，写写式子就知道了）

然后用决策单调性分治优化即可

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<vector>
using namespace std;
typedef long long ll;
typedef double db;
inline int read()
{
    int x=,f=; char ch=getchar();
    while(ch<''||ch>'') { if(ch=='-') f=-; ch=getchar(); }
    while(ch>=''&&ch<='') { x=(x<<)+(x<<)+(ch^); ch=getchar(); }
    return x*f;
}
const int N=;
const db INF=1e99;
int T,n,m,p;
vector <int> V[N];
db f[N][N],cst[N][N],dis[N];
void dfs(int x,int fa)
{
    int sz=V[x].size();
    if(sz==) { dis[x]=; return; }
    dis[x]=;
    for(int i=;i<sz;i++)
    {
        int &v=V[x][i]; if(v==fa) continue;
        dfs(v,x); dis[x]+=dis[v]+;
    }
    dis[x]/=sz-;
}
void solve(int i,int l,int r,int ql,int qr)
{
    int mid=l+r>>,pos=ql,R=min(qr,mid-); f[i][mid]=INF;
    for(int k=ql;k<=R;k++)
    {
        db val=f[i-][k]+cst[k][mid];
        if(val<f[i][mid]) f[i][mid]=val,pos=k;
    }
    if(l<mid) solve(i,l,mid-,ql,pos);
    if(mid<r) solve(i,mid+,r,pos,qr);
}
int main()
{
    T=read();
    while(T--)
    {
        n=read(),m=read(),p=read();
        for(int i=;i<=m-n;i++)
        {
            int a=read(),b=read();
            V[a].push_back(b); V[b].push_back(a);
        }
        for(int i=;i<=n;i++)
            for(auto A: V[i]) dfs(A,i);
        for(int i=;i<=n;i++)
        {
            cst[i][i]=;
            for(int j=i+;j<=n;j++)
            {
                cst[i][j]=cst[i][j-]+;
                for(auto A: V[j-])
                    cst[i][j]+=cst[i][j-]+ + dis[A];
            }
        }
        f[][]=; for(int i=;i<=n;i++) f[][i]=INF;
        for(int i=;i<=p;i++)
            solve(i,,n,,n);
        printf("%.4lf\n",f[p][n]);
        for(int i=;i<=m;i++) V[i].clear();
    }
    return ;
}