简单动态规划(4)——从入门到放弃

期望DP

对我们今天是来切水题的
（1）博物馆(BZOJ3270)
题面还是见黄学长的博客吧传送门
因为这里有环形，我们显然不能直接向傻X一样递推
我们定义$id[x][y]$表示一人在x，一人在y的状态
再标记$d[x]$为点$x$的度
$ratio[x]$为不转移的概率
然后$mat[id[x_1][y_1]][id[x_2][y_2]]$表示由状态$id[x_2][y_2]$转移到$id[x_1][y_1]$的概率贡献系数
如果$x_1=x_2，y_1=y_2$则该系数为$ratio[x]*ratio[y]$
如果只有$x_1{\not=}x_2$则该系数为$\frac{1-ratio[x]}{d[x]}*ratio[y]$
如果只有$y_1{\not=}y_2$则该系数为$\frac{1-ratio[y]}{d[y]}*ratio[x]$
很显然$x_1{\not=}x_2$且$y_1{\not=}y_2$时，该系数为$\frac{1-ratio[x]}{d[x]}*\frac{1-ratio[y]}{d[y]}$
然后高斯消元乱搞一波就能强势清场

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
using namespace std;
inline int read(){
    int i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<1)+(i<<3)+(ch^48);
    return i*f;
}
int buf[1024];
inline void write(int x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ;
}
#define stan 22
#define sten 666
int tot,und[stan],nxt[sten<<1],first[stan],goal[sten<<1],u,v;
int tx,ty,t1,t2;
int n,m,a,b,sze,pos;
double ratio[stan],mat[sten][sten];
inline int getord(int x,int y){
    return (x-1)*n+y;
}
inline void addedge(int a,int b){
    ++und[a];nxt[++tot]=first[a];first[a]=tot;goal[tot]=b;
    return ;
}
inline void build(int x,int y){
    --mat[getord(x,y)][getord(x,y)];
    for(int p=first[x];p;p=nxt[p])
        for(int q=first[y];q;q=nxt[q]){
            tx=goal[p];ty=goal[q];
            t1=getord(x,y);t2=getord(tx,ty);
            if(tx!=ty){
                if(tx==x&&ty==y) mat[t1][t2]+=ratio[tx]*ratio[ty];
                else if(tx==x) mat[t1][t2]+=ratio[tx]*(1-ratio[ty])/und[ty];
                else if(ty==y) mat[t1][t2]+=ratio[ty]*(1-ratio[tx])/und[tx];
                else mat[t1][t2]+=(1-ratio[tx])*(1-ratio[ty])/(und[tx]*und[ty]);
            }
        }
    return ;
}
inline void gauss(){
    for(int i=1;i<=sze;++i){
        int maxn=i;int j;
        for(j=i;!mat[j][maxn]&&j<=sze;++j);
        swap(mat[j],mat[maxn]);
        for(int j=1;j<=sze;++j)
            if(j!=maxn){
                double t=mat[j][maxn]/mat[maxn][maxn];
                for(int k=1;k<=sze+1;++k)
                    mat[j][k]-=t*mat[maxn][k];
            }
    }
}
signed main(){
    n=read();m=read();a=read();b=read();
    sze=n*n;
    mat[getord(a,b)][sze+1]=-1;
    for(int i=1;i<=n;++i)
        addedge(i,i);
    for(int i=1;i<=m;++i){
        u=read();v=read();
        addedge(u,v);
        addedge(v,u);
    }
    for(int i=1;i<=n;++i){
        scanf("%lf",&ratio[i]);
        --und[i];
    }
    for(int i=1;i<=n;++i)
        for(int j=1;j<=n;++j)
            build(i,j);
    gauss();
    for(int i=1;i<=n;++i){
        pos=getord(i,i);
        printf("%.6lf",mat[pos][sze+1]/mat[pos][pos]);
        if(i!=n)putchar(' ');
    }
    return 0;
}

（2）概率充电器(SHOI2014)
题面见链接传送门
其实这个题本来是可以直接用容斥求不能充电的概率一波带走的
但我就是想要正着三线推高地
我们需要的只是dfs两次
我们先钦定一个根节点，然后第一遍dfs维护每个节点被非父节点充电的概率。这个是非常naive的
然后我们要做的就是比较麻烦的一件事：加上来自父节点的概率贡献
首先，父节点有贡献的前提是，当前节点未处于充能态且当前节点对父节点没有贡献
然后就可以两次dfs完美解决了

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#define eps 1e-8
using namespace std;
inline int read(){
    int i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<3)+(i<<1)+(ch^48);
    return i*f;
}
int buf[1024];
inline void write(int x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ;
}
#define stan 555555
int tot,nxt[stan<<1],first[stan],goal[stan<<1],n,a,b;
double f1[stan],f2[stan],dis[stan<<1],c,ans;
void addedge(int a,int b,double c){
    nxt[++tot]=first[a];first[a]=tot;goal[tot]=b;dis[tot]=c;
    nxt[++tot]=first[b];first[b]=tot;goal[tot]=a;dis[tot]=c;
    return ;
}
void dfs1(int u,int fa){
    for(int p=first[u];p;p=nxt[p])
        if(goal[p]!=fa){
            dfs1(goal[p],u);
            f1[u]=f1[u]+dis[p]*f1[goal[p]]-f1[u]*dis[p]*f1[goal[p]];
        }
    return ;
}
void dfs2(int u,int fa){
    ans+=f2[u];
    for(int p=first[u];p;p=nxt[p])
        if(goal[p]!=fa){
            double oppo=1.0000000-dis[p]*f1[goal[p]];
            if(abs(oppo)<eps) f2[goal[p]]=1.0000000;
            else{
                double pro=(f2[u]-dis[p]*f1[goal[p]])/(1.0000000-dis[p]*f1[goal[p]]);
                f2[goal[p]]=pro*dis[p]+f1[goal[p]]-f1[goal[p]]*pro*dis[p];
            }
            dfs2(goal[p],u); 
        }
    return ;
}
signed main(){
    n=read();
    for(int i=1;i<n;++i){
        a=read();b=read();c=read();
        addedge(a,b,c*0.01);
    }
    for(int i=1;i<=n;++i)
        f1[i]=read()*0.01;
    dfs1(1,0);
    f2[1]=f1[1];
    dfs2(1,0);
    printf("%.6lf",ans);
    return 0;
}

（3）分手是祝愿(六省联考2017)
题面照例见链接传送门
首先我们来考虑一下什么样的策略才是最优策略
很明显，每一个开关除自身外只会影响编号比它小的灯
所以对于开关$i$，在区间$[1,i]$中具有不可替代性。
这个直接倒序贪心外加模拟就可以得到对于整个序列的最小操作次数$tot$
显然每个开关至多被操作一次
所以当$k\geq n$或者是$k\geq tot$时直接输出$tot$即可
mdzz这都能有80分...
然后我们来考虑正解
设$f[i]$为还需要$i$步关掉所有的灯
定义$step[i]$为从$f[i]$转移到$f[i-1]$的期望步数
很明显有$step[i]=\frac{i}n*1+\frac{n-i}n*(step[i+1]+step[i]+1)$
然后就是简单的递推又求和

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#define mod 100003
#define int long long
using namespace std;
inline int read(){
    int i=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch);ch=getchar())
        if(ch=='-') f=-1;
    for(;isdigit(ch);ch=getchar())
        i=(i<<1)+(i<<3)+(ch^48);
    return i*f;
}
int buf[1024];
inline void write(int x){
    if(!x){putchar('0');return ;}
    if(x<0){putchar('-');x=-x;}
    while(x){buf[++buf[0]]=x%10,x/=10;}
    while(buf[0]) putchar(buf[buf[0]--]+48);
    return ;
}
#define stan 111111
bool state[stan];
int n,k,tot,ans,nxtmean[stan];
inline int ksm(int a,int b){
    int ret=1;
    while(b){
        if(b&1) ret=(ret*a)%mod;
        b>>=1;
        a=(a*a)%mod;
    }
    return ret;
}
signed main(){
    n=read();k=read();
    for(int i=1;i<=n;++i)
        state[i]=read();
    for(int i=n;i;--i)
        if(state[i]){
            for(int j=1;j*j<=i;++j)
                if(i%j==0){
                    state[j]^=1;
                    if(j*j!=i) state[i/j]^=1;
                }
            ++tot;
        }
    if(n<=k||k>=tot){
        for(int i=1;i<=n;++i)
            tot=(tot*i)%mod;
        write(tot);
        return 0;
    }else{
        for(int i=n;i;--i)
            nxtmean[i]=(((n-i)*nxtmean[i+1]%mod+n)%mod*ksm(i,mod-2))%mod;
        for(int i=tot;i>k;--i)
            ans=(ans+nxtmean[i])%mod;
        ans=(ans+k)%mod;
        for(int i=1;i<=n;++i)
            ans=(ans*i)%mod;
        write(ans);
        return 0;
    }
}