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

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_37517391/article/details/79968517

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

P1879 玉米田

题解

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

然后状态转移:dp[i+1][nS]=nSpS=0nSdp[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

  1. 当前i1没有换的时候,第i1课程是教室a[i1]的概率为1.0,转移过来的数值是(dp[i1][j][0]+mincost(a[i1],a[i])1.01.0

  2. 当前i1换了的时候,如果换成功了,第i1课程是教室b[i1]的概率为1.0,转移过来的数值是(dp[i1][j][1]+mincost(b[i1],a[i])p[i1]1.0

  3. 当前i1换了的时候,如果换失败了,第i1课程是教室b[i1]的概率为1.0,转移过来的数值是(dp[i1][j][1]+mincost(a[i1],a[i])(1p[i1])1.0

dp[i][j][1]的转移方程:

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

  1. i1不申请换教室。
    转移过来的数值为(dp[i1][j1][0]+G(a[i1],b[i]))p[i]+(dp[i1][j1][0]+G(a[i1],a[i]))(1p[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个点就可以确定一条抛物线了。
我们n2地枚举两两点的组合,生成对应的抛物线,这样的话,最差情况下所需的不会超过n2条抛物线。
我们把当前构造出来的每条抛物线,把这条抛物线能经过的所有点压缩成为一个状态。
问题就转变成了状态压缩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;
}

后记

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

阅读更多

扫码向博主提问

phython96

ACM、OI、C++
去开通我的Chat快问
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页