记

练习一下动态规划水题系列，防止脑子生锈。

P1879 玉米田

题解

非常典型的状态压缩 $DP$ ，先预处理出所有可行的状态 $S$ 。
然后逐行 $DP$ ，定义状态 $dp[i][S]$ 表示的含义是前 $i$ 行满足条件，并且第 $i$ 行的状态为 $S$ ，可行的方案数。

然后状态转移: $dp[i+1][nS] = \sum_{nS与pS=0 且 nS可行 }{dp[i][pS]}$

代码

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxs = 100000;
const int mod = 1e8;
int state[maxs];
int cnt = 0;
int dp[13][maxs];
int bks[13];
int n,m;
int main(){
    cin>>m>>n;

    for(int i = 1;i <= m;++i){
        for(int j = 0;j < n;++j){
            int t;
            cin>>t;
            if(t == 0) bks[i] |= (1<<j);
        }
    }

    for(int i = 0;i < (1<<n);++i){
        if(i&(i<<1)) continue;
        else state[cnt++] = i;
    }
    dp[0][0] = 1; 
    int ans = 0;
    for(int i = 1;i <= m;++i){
        for(int j = 0;j < cnt;++j){
            int nS = state[j];
            if(nS & bks[i]) continue;
            for(int k = 0;k < cnt;++k){
                int pS = state[k];
                if(pS & nS) continue;
                dp[i][nS] += dp[i-1][pS];
                dp[i][nS] %= mod;
            }   
            if(i == m) ans = (ans + dp[i][nS])%mod;
        }
    }
    cout<<ans<<endl;
}

P1850 换教室

题解

有关概率期望的dp，但也不是很难，却花了我很长时间，原因是初值条件没搞清楚。

定义状态

$dp[i][j][0]$ 表示前 $i$ 个课程，换了 $j$ 个，且第 $i$ 个没有换，期望值的最小值。

$dp[i][j][1]$ 表示前 $i$ 个课程，换了 $j$ 个，且第 $i$ 个申请换了，期望值的最小值。

状态转移方程

$dp[i][j][0]$ 的转移方程：

由于第 $i$ 个课程没有换教室，所以教室是 $a[i]$ 的概率是 $1.0$ 。

当前 $i-1$ 没有换的时候，第 $i-1$ 课程是教室 $a[i-1]$ 的概率为 $1.0$ ，转移过来的数值是 $(dp[i-1][j][0] + mincost(a[i-1],a[i])*1.0*1.0$
当前 $i-1$ 换了的时候，如果换成功了，第 $i-1$ 课程是教室 $b[i-1]$ 的概率为 $1.0$ ，转移过来的数值是 $(dp[i-1][j][1] + mincost(b[i-1],a[i])*p[i-1]*1.0$
当前 $i-1$ 换了的时候，如果换失败了，第 $i-1$ 课程是教室 $b[i-1]$ 的概率为 $1.0$ ，转移过来的数值是 $(dp[i-1][j][1] + mincost(a[i-1],a[i])*(1-p[i-1])*1.0$

$dp[i][j][1]$ 的转移方程：

由于第 $i$ 个课程申请换教室了，成功的概率是 $p[i]$ ，失败的概率是 $1-p[i]$ 。

$i-1$ 不申请换教室。
转移过来的数值为 $(dp[i-1][j-1][0]+G(a[i-1],b[i]))*p[i]+(dp[i-1][j-1][0]+G(a[i-1],a[i]))*(1-p[i])$

剩下的3种情况看我代码里写的吧，懒得去写了。

代码

#include <iostream>
#include <cstdio>
using namespace std;
double dp[2][2007][2];
int G[307][307];
int n,m,v,e;
int a[2007],b[2007];
double p[2007];
int main(){
    cin>>n>>m>>v>>e;
    for(int i = 0;i < n;++i){
        scanf(" %d",&a[i]);
    }

    for(int i = 0;i < n;++i){
        scanf(" %d",&b[i]);
    }

    for(int i = 0;i < n;++i){
        scanf(" %lf",&p[i]);
    }

    for(int i = 1;i <= v;++i){
        for(int j = 1;j <= v;++j){
            if(i == j) continue;
            G[i][j] = G[j][i] = 1e8;
        }
    }

    for(int i = 0;i < e;++i){
        int u,v,t;
        scanf(" %d %d %d",&u,&v,&t);
        G[v][u] = G[u][v] = min(t,G[v][u]);
    }

    for(int k = 1;k <= v;++k)
    for(int i = 1;i <= v;++i){
        for(int j = 1;j <= v;++j){
            G[i][j] = min(G[i][j],G[i][k] + G[k][j]);
        }
    }
    for(int i = 0;i < 2007;++i){
        dp[0][i][0] = dp[0][i][1] = dp[1][i][0] = dp[1][i][1] = 1e18;
    }
    dp[0][0][0] = 0;
    //dp[0][0][1] = 0;
    //dp[0][1][0] = 0;
    dp[0][1][1] = 0;
    for(int i = 1;i < n;++i){
        for(int j = 0;j <= min(m,i+1);++j){
            dp[i&1][j][0] = (dp[(i-1)&1][j][0]+G[a[i-1]][a[i]]);
            if(j == 0) continue;
            dp[i&1][j][0] = min(dp[i&1][j][0],(dp[(i-1)&1][j][1]+G[b[i-1]][a[i]])*p[i-1]
                        +(dp[(i-1)&1][j][1]+G[a[i-1]][a[i]])*(1-p[i-1]));
            dp[i&1][j][1] = (dp[(i-1)&1][j-1][0]+G[a[i-1]][b[i]])*p[i]
                    +(dp[(i-1)&1][j-1][0]+G[a[i-1]][a[i]])*(1-p[i]);
            if(j <= 1) continue;
            dp[i&1][j][1] = min(dp[i&1][j][1],dp[(i-1)&1][j-1][1]
                    +G[b[i-1]][b[i]]*p[i-1]*p[i]
                    +G[a[i-1]][b[i]]*(1-p[i-1])*p[i]
                    +G[b[i-1]][a[i]]*(p[i-1])*(1-p[i])
                    +G[a[i-1]][a[i]]*(1-p[i-1])*(1-p[i]));
        }
    }
    double ans = 1e18;
    for(int i = 0;i <= min(m,n);++i){
        ans = min(ans,dp[(n-1)&1][i][0]);
        ans = min(ans,dp[(n-1)&1][i][1]);
    }
    printf("%.2lf\n",ans);
}

P2831 愤怒的小鸟

题解

比较经典的动态规划问题。

由于一条抛物线至少经过1个点。我们构造 $n$ 条抛物线，分别经过这 $n$ 个点，每条线都只能覆盖 $1$ 只猪。然后我们知道除了 $(0,0)$ 点，剩下再有 $2$ 个点就可以确定一条抛物线了。
我们 $n^2$ 地枚举两两点的组合，生成对应的抛物线，这样的话，最差情况下所需的不会超过 $n^2$ 条抛物线。
我们把当前构造出来的每条抛物线，把这条抛物线能经过的所有点压缩成为一个状态。
问题就转变成了状态压缩dp。

定义状态 $dp[S]$ 表示覆盖 $S$ 状态的点，最小需要多少条抛物线。

状态转移方程：
$dp[S|state[i]] = min(dp[S|state[i]],dp[S]+1)$
其中 $state[i]$ 表示第 $I$ 条抛物线所能经历的点集状态。

代码

#include <iostream>
#include <cstring>
#include <cstdio>
#define pr(x) cout<<#x<<":"<<x<<endl
using namespace std;
int dp[1<<19];
int n,m;
long double a[400],b[400];
int cover[400];
int cnt;
long double x[40],y[20];
inline long double fabs(long double x) {return x > 0 ? x:-x;}
long double eps = 0.000000001;
int main(){
    int T;
    cin>>T;
    while(T--){
        cin>>n>>m;
        cnt = 0;
        memset(dp,0x3f,sizeof(dp));
        for(int i = 0;i < n;++i)
            cin>>x[i]>>y[i];
        for(int i = 0;i < n;++i){
            for(int j = i+1;j < n;++j){
                if(i == j) continue;
                if(fabs(x[i]-x[j]) < eps) {
                    continue;
                }
                else{
                    a[cnt] = (x[i]*y[j]-x[j]*y[i])/(x[j]*x[i]*(x[j]-x[i]));
                    b[cnt] = (y[i] - a[cnt]*x[i]*x[i])/x[i];
                    if(a[cnt] >= 0 || fabs(a[cnt]) < eps) continue;
                    else cnt++;
                }
            }
        }

        dp[0] = 0;

        for(int i = 0;i < cnt;++i){
            int c = 0;
            for(int j = 0;j < n;++j){
                long double f = a[i]*x[j]*x[j] + b[i]*x[j];
                if(fabs(f - y[j]) < eps) c |= 1<<j;
            }
            cover[i] = c;
        }
        for(int i = 0;i < n;++i){
            cover[cnt++] = 1<<i;
        }

        for(int S = 0;S < (1<<n);++S){
            for(int j = 0;j < cnt;++j){
                dp[S|cover[j]] = min(dp[S|cover[j]],dp[S] + 1);
            }
        }

        cout<<dp[(1<<n)-1]<<endl;
    }
    return 0;
}

P1131 时态同步

题解

这是一道树形dp。

这道题的含义相当于给边添加最小的数，使得从根节点道每个叶子节点路径长度都相同。

直接进行dfs，回溯的时候保证子树满足题设条件(从根节点道每个叶子节点路径长度都相同)。

代码

// luogu-judger-enable-o2
#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
const int maxn = 500007;
typedef pair<int,int> pii;
vector<pii> G[maxn];
int n,root;
long long ans = 0;
int dfs(int u,int fa){
    vector<int> tv;
    int mx = 0;
    for(auto p : G[u]){
        int v = p.first;
        int c = p.second;
        if(v == fa) continue;
        int res = dfs(v,u)+c;
        tv.push_back(res);
        mx = max(mx,res);
    }

    for(auto v : tv){
        ans += mx - v;
    }

    return mx;
}
int main(){
    scanf("%d %d",&n,&root);
    for(int i = 0;i < n-1;++i){
        int u,v,c;
        scanf("%d%d%d",&u,&v,&c);
        G[u].push_back(make_pair(v,c));
        G[v].push_back(make_pair(u,c));
    }
    dfs(root,0);
    cout<<ans<<endl;
}

后记

这几道题目都是比较经典的题目，就是太老了，下次应该做一些新的题，这样才能跟上时代潮流呀。

洛谷-省选斗兽场-动态规划1

记

P1879 玉米田

题解

代码

P1850 换教室

题解

定义状态

状态转移方程

$dp[i][j][0]$ 的转移方程：

$dp[i][j][1]$ 的转移方程：

代码

P2831 愤怒的小鸟

题解

代码

P1131 时态同步

题解

代码

后记

猜你喜欢

洛谷-省选斗兽场-动态规划1

记

P1879 玉米田

题解

代码

P1850 换教室

题解

定义状态

状态转移方程

dp[i][j][0] d p [ i ] [ j ] [ 0 ] dp[i][j][0]的转移方程：

dp[i][j][1] d p [ i ] [ j ] [ 1 ] dp[i][j][1]的转移方程：

代码

P2831 愤怒的小鸟

题解

代码

P1131 时态同步

题解

代码

后记

猜你喜欢

$dp[i][j][0]$ 的转移方程：

$dp[i][j][1]$ 的转移方程：