DP刷题（线性）

CoCoa-Ck

于 2024-07-31 13:16:45 发布

阅读量329

点赞数 9

文章标签：算法动态规划 c++

本文链接：https://blog.csdn.net/cocoack/article/details/140814235

版权

都是来自《算法竞赛进阶指南》这本书：

1.线性DP：https://www.luogu.com.cn/problem/SP15637

首先，我们需要观察到几个性质：

我们从身高从高到低排

1.后排的人数 $\geq$ 前排的人数：假如前排人多，那么后排的相对应的位置一定比前排低。

2.我们对于每一行，排队的人都是从左到右连续的。

综上，满足这两个规则也就一定可以表示出来，因此我们可以忽略排的人的身高等细节问题，只需要知道每一行排了多少即可。

于是我们令 $dp[a][b][c][d][e]$ 表示各行排的人数。转移就显而易见了。

AC代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
ll dp[31][31][31][31][31];
int main(){
   while(cin>>n,n){

        int s[5]={0};
        for(int i=0;i<n;i++) cin>>s[i];
        memset(dp,0,sizeof(dp));
        dp[0][0][0][0][0]=1;
        for(int a=0;a<=s[0];a++){
            for(int b=0;b<=min(s[1],a);b++){
                for(int c=0;c<=min(b,s[2]);c++){
                    for(int d=0;d<=min(c,s[3]);d++){
                        for(int e=0;e<=min(s[4],d);e++){
                            ll &v=dp[a][b][c][d][e];
                            if(a&&(a-1)>=b) v+=dp[a-1][b][c][d][e];
                            if(b&&(b-1>=c)) v+=dp[a][b-1][c][d][e];
                            if(c&&(c-1)>=d) v+=dp[a][b][c-1][d][e];
                            if(d&&(d-1)>=e) v+=dp[a][b][c][d-1][e];
                            if(e) v+=dp[a][b][c][d][e-1];
                        }
                    }
                }
            }
        }
        cout << dp[s[0]][s[1]][s[2]][s[3]][s[4]] << endl;
     
    }
    return 0;
}

2.DP+离散化：https://www.acwing.com/problem/content/275/

容易想到用 $dp[i][j]$ 表示完成前i个构造，最后一个是j的最小值。但是j的范围就已经会TLE了。

于是我们观察最优构造的性质：

如图所示：

红色点是B的构造，假如这是一组最优解，对于框起来的3个点我们讨论：

1.假如他们横坐标的A的 $\geq A3$ 的点多，那么就整体上移到A3一定更优，当A6到了A3，我们再类似的讨论A4,A5。

2.假如少的化A4先移到A2，后面类别即可。

于是我们可以得出结论：存在一种构造B的方案，使B都在A中出现过。

注意可以用前缀和思想优化掉一维循环。

具体见代码：

AC代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 2010, INF = 0x3f3f3f3f;
int n;
int a[N], b[N];
int dp[N][N];
int work()
{
    for (int i = 1; i <= n; i ++ ) b[i] = a[i];
    sort(b + 1, b + n + 1);
    for(int i=1;i<=n;i++) dp[1][i]=abs(a[1]-b[i]);
    for (int i = 2; i <= n; i ++ )
    {
        int minv = INF;//前缀和的思想
        for (int j = 1; j <= n; j ++ )
        {
            minv = min(minv, dp[i - 1][j]);
            dp[i][j] = minv + abs(a[i] - b[j]);
        }
    }
    int res = INF;
    for (int i = 1; i <= n; i ++ ) res = min(res, dp[n][i]);
    return res;
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &a[i]);
    int res = work();
    reverse(a + 1, a + n + 1);
    res = min(res, work());
    printf("%d\n", res);
}

3.DP(排除冗余计算）：https://www.acwing.com/problem/content/276/

首先，因为有一个人一定是在指定位置上，于是我们可以设状态为 $dp[i][x][y]$ 表示到i轮，其他两个人的位置。（ $dp[i][x][y][z]$ 中的一维是多余的）

其次，我们需要知道填表与刷表都可行（相当于图的入边与出边）

我们考虑状态转移，发现直接求情况太多，于是我们考虑它可以转移到的状态即可。

AC代码：

#include<bits/stdc++.h>
using namespace std;
int n,m;
int w[210][210];
int p[10010];
int dp[1001][210][210];
int main(){
    cin>>m>>n;
    for(int i=1;i<=m;i++){
        for(int j=1;j<=m;j++) cin>>w[i][j];
    }
    for(int i=1;i<=n;i++) cin>>p[i];
    memset(dp,0x3f,sizeof(dp));
    p[0]=3;
    dp[0][1][2]=dp[0][2][1]=0;
    for(int i=0;i<n;i++){
        for(int x=1;x<=m;x++){
            for(int y=1;y<=m;y++){
                int z=p[i],u=p[i+1];
                if(x==y||y==z||x==z) continue;
                dp[i+1][x][y]=min(dp[i+1][x][y],dp[i][x][y]+w[z][u]);
                dp[i+1][z][y]=min(dp[i+1][z][y],dp[i][x][y]+w[x][u]);
                dp[i+1][z][x]=min(dp[i+1][z][x],dp[i][x][y]+w[y][u]);
                dp[i+1][y][x]=min(dp[i+1][y][x],dp[i][x][y]+w[z][u]);
                dp[i+1][y][z]=min(dp[i+1][y][z],dp[i][x][y]+w[x][u]);
                dp[i+1][x][z]=min(dp[i+1][x][z],dp[i][x][y]+w[y][u]);
            }
        }
    }
    int res=1e9;
    for(int x=1;x<=m;x++){
        for(int y=1;y<=m;y++){
            int z=p[n];
            if(x==y||y==z||x==z) continue;
            res=min(res,min(dp[n][x][y],dp[n][y][x]));
        }
    }
    cout<<res;
}

4.DP+贪心 +转移方程的转化（多少个1）：https://www.acwing.com/problem/content/279/

首先：贪心：怨气越大，分配越多。

我们从大到小排个序，令 $dp[i][j]$ 表示前i个小朋友分配J个。

考虑状态转移：这里的划分依据是最后一位是否为一

1.假如最后一个 $\geqslant 2$ ，那么我们每个小朋友-1个不影响结果。于是： $dp[i][j]=dp[i][j-i]$

2.假如最后是一段连续的1，于是： $dp[i][j]=max(dp[i-k][j-k]+(s[i]-s[i-k])*(i-k))$

AC代码：

#include<bits/stdc++.h>
using namespace std;
int n,m;
pair<int,int> g[5010];
int s[30110],dp[40][5040],ans[31];
int main(){
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>g[i].first;
        g[i].second=i;
    }
    sort(g+1,g+n+1);
    reverse(g+1,g+n+1);
    for(int i=1;i<=n;i++) s[i]=s[i-1]+g[i].first;
    memset(dp,0x3f,sizeof(dp));
    dp[0][0]=0;
    for(int i=1;i<=n;i++){
        for(int j=1;j<=m;j++){
            if(j<i) continue;
            dp[i][j]=min(dp[i][j],dp[i][j-i]);
            for(int k=1;k<=i;k++){
                dp[i][j]=min(dp[i][j],dp[i-k][j-k]+(s[i]-s[i-k])*(i-k));
            }
        }
    }
    cout<<dp[n][m]<<endl;
    int i=n,j=m,h=0;
    while(i){
        if(dp[i][j]==dp[i][j-i]){
            h++;
            j-=i;
        }
        else{
            for(int k=1;k<=i;k++){
                if(dp[i][j]==dp[i-k][j-k]+(s[i]-s[i-k])*(i-k)){
                    for(int u=i-k+1;u<=i;u++) ans[g[u].second]=1+h;
                    i-=k;
                    j-=k;
                    break;
                }
            }
        }
    }
    for(int i=1;i<=n;i++) cout<<ans[i]<<" ";
}

CoCoa-Ck

关注

9
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
DP刷题（线性）

综上，满足这两个规则也就一定可以表示出来，因此我们可以忽略排的人的身高等细节问题，只需要知道每一行排了多少即可。的点多，那么就整体上移到A3一定更优，当A6到了A3，我们再类似的讨论A4,A5。我们考虑状态转移，发现直接求情况太多，于是我们考虑它可以转移到的状态即可。于是我们可以得出结论：存在一种构造B的方案，使B都在A中出现过。前排的人数：假如前排人多，那么后排的相对应的位置一定比前排低。首先，因为有一个人一定是在指定位置上，于是我们可以设状态为。2.我们对于每一行，排队的人都是从左到右连续的。
复制链接

扫一扫