ACM新手DAY 14 简单动态规划（背包、LIS等）

最新推荐文章于 2022-03-08 16:37:58 发布
最新推荐文章于 2022-03-08 16:37:58 发布
阅读量123 收藏
点赞数
分类专栏： ACM 文章标签： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/listenhhh/article/details/97677713
版权

题解

A - Common Subsequence

题目: 求最长公共子序列

  • LCS
//LCS
#include<bits/stdc++.h>
#include<iostream>
using namespace std;
const int INF = 1<<30;
const int maxn = 1010;
int dp[maxn][maxn];
int main()
{
    string s1, s2;
    while(cin >>s1 >>s2)
    {
        memset(dp, 0, sizeof dp);//dp初始化

        for(int i=0; i<s1.size(); i++)//记录每个状态的最长
            for(int j=0; j<s2.size(); j++)
            {
                if(s1[i]==s2[j])
                    if(i>0 && j>0)
                        dp[i][j] = dp[i-1][j-1]+1;
                    else
                        dp[i][j] = 1;
                if(i > 0)//甄选长度部分
                    dp[i][j] = max(dp[i][j], dp[i-1][j]);
                if(j > 0)
                    dp[i][j] = max(dp[i][j], dp[i][j-1]);
            }

        int ans=0;
        for(int i=0; i<s1.size(); i++)//找到最长
            for(int j=0; j<s2.size(); j++)
                ans = max(ans, dp[i][j]);
        cout <<ans <<endl;
    }

    return 0;
}

B - Super Jumping! Jumping! Jumping!

题意：最长上升子序列

  • LIS
  • 逻辑部分的变化
//LIS
        memset(dp, 0, sizeof dp);//dp初始化
        for(int i=0; i<n; i++) cin >> num[i]; //读入数组
        dp[0] = num[0];
        for(int i=0; i<n; i++)//dp状态记录
        {
            int flag =0;
            for(int j =0; j<i; j++)
                if(num[i] > num[j])
                {
                    dp[i] = max(dp[i],dp[j] + num[i]);
                    flag =1;
                }
            if(!flag)
                dp[i] = num[i];
        }
        int mx=0;
        for(int i=0; i<n; i++)//遍历找最大
            mx = max(mx, dp[i]);
        cout << mx << endl;

C - Bone Collector

  • 0-1背包，不需要恰好装满，也算PPT里面体积为1那种情况吧
//0-1背包，一维数组，不需要恰好装满
#include<bits/stdc++.h>
using namespace std;
const int INF = 1<<30;
const int maxn = 1010;
int dp[maxn], v[maxn], w[maxn];
int main()
{
    int T;
    cin >>T;
    while(T--)
    {
        int N, V;
        cin >>N >>V;
        for(int i=1; i<=N; i++) cin >>w[i];//读价值
        for(int i=1; i<=N; i++) cin >>v[i];//读体积
        memset(dp, INF, sizeof dp);//dp初始化，不用恰好装满
        for(int i=v[1]; i<=V; i++)
            dp[i] = w[1];

        for(int i=2; i<=N; i++)
            for(int j=V; j>=v[i]; j--)
                dp[j] = max(dp[j], dp[j-v[i]]+w[i]);

        cout <<dp[V] <<endl;
    }
    return 0;
}

D - 饭卡

题目：电子科大本部食堂的饭卡有一种很诡异的设计，即在购买之前判断余额。如果购买一个商品之前，卡上的剩余金额大于或等于5元，就一定可以购买成功（即使购买后卡上余额为负），否则无法购买（即使金额足够）。所以大家都希望尽量使卡上的余额最少。 某天，食堂中有n种菜出售，每种菜可购买一次。已知每种菜的价格以及卡上的余额，问最少可使卡上的余额为多少。

  • 找到最贵的菜，最后买，然后类似0-1背包，逼近5元余额
//先找到最贵的菜，放到最后买,像0-1背包的一维数组
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int dp[maxn], w[maxn];
int main()
{
    int n, m;
    while(cin >> n && n)
    {
        memset(dp, 0, sizeof dp);
        for(int i=0; i<n; i++) cin >> w[i];//读入价值
        sort(w,w+n);//升序排序
        cin >> m;
        for(int i=0; i<n-1; i++)//对花费的无限逼近
        {
            for(int j=m-5; j>=w[i]; j--)
            {
                dp[j]=max(dp[j],dp[j-w[i]]+w[i]);
            }
        }
        int ans =  dp[m-5];
        if(m<5) cout << m << endl;
        else cout << m-ans-w[n-1] << endl;//w[n-1]放在最后买
    }
    return 0;
}

F - 悼念512汶川大地震遇难同胞——珍惜现在，感恩生活

  • 多重背包
//多重背包
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1000;
int dp[maxn], num[maxn], weight[maxn], val[maxn];
int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        int n, m;
        cin >> n >> m;
        memset(dp, 0, sizeof dp);
        for(int i=1; i<=m; i++)
        {
            cin >> num[i] >> weight[i] >> val[i];
            for(int j=0; j<val[i]; j++)
                for(int k=n; k>=num[i]; k--)
                    dp[k]=max(dp[k],dp[k-num[i]]+weight[i]);
        }
        cout<<dp[n]<<endl;
    }
    return 0;
}

E - Piggy-Bank（补题）

  • 完全背包
  • 不过价值最大改成了求价值最小
  • 自己的超时的代码
//完全背包，且求的是价值最小
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;//反转的时候这里也变了，变成最大了!!
const int maxn = 510;
int w[maxn], v[maxn], dp[maxn];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(dp,inf,sizeof(dp));
        dp[0]=0;
        int a, b;
        scanf("%d%d",&a,&b);
        int m=b-a;
        int n;
        scanf("%d",&n);
        for(int i=1; i<=n; i++)
            cin>>v[i]>>w[i];
        for(int i=1; i<=n; i++)
        {
            for(int j=w[i]; j<=m; j++)
                dp[j]=min(dp[j],dp[j-w[i]]+v[i]);//用dp存的是钱的数目
        }
        if(dp[m]==inf)printf("This is impossible.\n");
        else printf("The minimum amount of money in the piggy-bank is %d.\n",dp[m]);
    }
    return 0;
}
  • 别人的AC代码
#include<iostream>
#include<cstdio>
#include<algorithm>
#define maxn 0x3f3f3f3f
using namespace std;
//#define maxn 0x3f3f3f3f
int t,e,f,n;
int p[505], w[505], dp[10005];
int main()
{
    scanf("%d",&t);
    while (t--)
    {
        scanf("%d%d",&e,&f);
        scanf("%d",&n);
        for (int i = 0; i < n; i += 1)  scanf("%d%d",&p[i],&w[i]);
        for (int i = 0; i <= f-e; i += 1)   dp[i] = maxn;
        dp[0] = 0;
        for (int i = 0; i < n; i += 1)
            for (int j = w[i]; j <= f-e; j += 1)
                dp[j] = min(dp[j],dp[j-w[i]]+p[i]);
        if (dp[f-e] != maxn) printf("The minimum amount of money in the piggy-bank is %d.\n",dp[f-e]);
        else printf("This is impossible.\n");
    }
    return 0;
}

I - 数数塔

题目：有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？并输出最大和的路径。在这里插入图片描述

  • 动态规划
  • 从倒数第二行起往上，找每一个点的下面对应的两个里面最大的，这样往上找去，直到最后只剩一个点。对于输出路线和判断路线数目的要求，可在代码里体现。
#include <iostream>
using namespace std;
const int mx = 100;
struct node
{
    int num, dp, dir;
    int bl;
} a[mx][mx];//num用来记录每个点的数，dp是动态规划用的，dir是记录方向，用来输出坐标的，bl是判断路径是否有多条的
int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        int n;
        cin >> n;
        for(int i = 0; i < n; i++)//输入数塔
        {
            for(int j = 0; j <= i; j++)
            {
                cin >> a[i][j].num;
                a[i][j].dp = a[i][j].num;
                a[i][j].dir = 0;
                a[i][j].bl = 0;
            }
        }
        int bl = 0, bl2 = 0, cou(0);
        int tmp;
        for(int i = n-2; i >= 0; i--)//从倒数第二行开始遍历啦
        {
            for(int j=0; j <= i; j++)
            {
                if (a[i+1][j].dp > a[i+1][j+1].dp)	//左边大
                {
                    a[i][j].dir = 0;		//选择左边
                    a[i][j].dp += a[i+1][j].dp;//dp计数
                    if(a[i+1][j].bl)
                        a[i][j].bl = 1;
                }
                else
                {
                    if(a[i+1][j].dp == a[i+1][j+1].dp)
                    {
                        a[i][j].bl = 1;
                    }
                    a[i][j].dir = 1;
                    a[i][j].dp += a[i+1][j+1].dp;
                    if(a[i+1][j+1].bl)
                        a[i][j].bl = 1;
                }
            }
        }
        cout << a[0][0].dp << endl;//最大值
        if(a[0][0].bl) cout << "There are several solutions!" <<endl;
        else
            for(int i = 0, j = 0; i< n; i++)
            {
                cout << "(" << i << ", " << j << ")" ;
                if(i+1 < n) cout << " -> ";
                else cout << endl;
                j += a[i][j].dir;
            }
    }
    return 0;
}
Listening~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ACM算法总结 动态规划（一）
01-20
总的来说，动态规划是一种强大的工具，广泛应用于解决最优化问题，如背包问题、最长公共子序列、旅行商问题等。理解动态规划的思想，掌握状态表示、状态转移方程和边界条件的设定，对于解决这类问题至关重要。通过...
ACM：动态规划，01背包问题
u010470972的专栏
06-19 1796
题目： 有n件物品和一个容量为C的背包。（每种物品均只有一件）第i件物品的体积是v[i]，重量是w[i]。选一些物品装到这个背包中，使得背包内物品在总体积不超过C的前提下重量尽量大。 解法：两种思路： 第一种：d(i, j)表示“把第i,i+1,i+2,...n个物品装到容量为j的背包中的接下来的最大总重量”。             d(i, j) = max{d(i+1, j),
day4：选拔赛3 && 简单动态规划
serendipity的博客
08-20 174
day4：选拔赛3 && 简单动态规划 既然热爱，那就坚持，昨天偷懒去了，今天把昨天的总结补上 上午还是照常的听课，开始以为是简单DP，觉得会挺简单的（仿佛有点骄傲…），然而发现自己原来就只会拿几道简单的模板题，例如：数塔，0-1背包（裸的），最长上升子序列，最长公共子序列 但是遇到稍微变形就不会了，就拿选拔赛1的D题，一道几乎是裸的LIS的题，居然没做出来，心塞… 虽然上午感觉懂...
ACM动态规划总结
u013862444的博客
09-12 535
动态规划一直是ACM竞赛中的重点，也是难点（对于我这种水平），因为该算法时间效率高，代码量少，多元性强、灵活度高，主要考察思维能力、建模抽象能力。学了这么久动态规划，虽然还只是个菜菜= =，但还是想总结一下，总得给学弟学妹留下一些什么吧。                                                                              
ACM动态规划总结(by utobe67)
galesaur_wcy
02-23 238
 动态规划一直是ACM竞赛中的重点，也是难点（对于我这种水平），因为该算法时间效率高，代码量少，多元性强、灵活度高，主要考察思维能力、建模抽象能力。学了这么久动态规划，虽然还只是个菜菜= =，但还是想总结一下，总得给学弟学妹留下一些什么吧。                                                                                ...
暑假训练DAY11动态规划
FLY_WHITE的博客
08-05 384
A - Race  UVA - 12034  Description   Tamim and Lina, two of the biggest mega minds of Bangladesh went to a far country. They ate, coded and wandered around, even in their holidays. They passed sev...
动态规划
jianxingzhang的博客
02-19 831
动态规划一直是ACM竞赛中的重点，同时又是难点，因为该算法时间效率高，代码量少，多元性强，主要考察思维能力、建模抽象能力、灵活度。 本人动态规划博客地址：http://blog.csdn.net/cc_again/article/category/1261899 ******************************************************************...
kuangbin专题十二 基础DP
qw991的博客
03-08 425
kuangbin专题十二 基础DPA - HDU1024 Max Sum Plus PlusA - HDU1024 Max Sum Plus PlusB - HDU1029 Ignatius and the Princess IVC - HDU1069 Monkey and BananaD - HDU1074 Doing HomeworkE - Hdu1087 Super Jumping! Jumping! Jumping!F - Hdu1114 Piggy-BankG - HDU1176 免费馅饼H -
ACM刷题之路（十六）Acm程序设计竞赛自制模板
Designer 小郑的技术博客
04-18 2244
前言 本模板是我在备战省赛的时光中，把复习过的和新学的算法中比较常用的代码、思路，整合成了模板，供以后的ACM竞赛直接使用，因为时间匆忙、水平有限，若有不足之处，欢迎大佬提出。本版本为V1.0版，会不定期更新。 以下所有代码都是我个人手敲，并且通过HDU、POJ等知名OJ上做题实践验证过的结果，是我两个月的成果。 水平有限，代码比较累赘，以后有机会进一步减少少考的算...
动态规划总结
qq19971017的博客
12-15 370
转载 http://blog.csdn.net/tobewhatyouwanttobe/article/details/42805225          动态规划一直是ACM竞赛中的重点，也是难点（对于我这种水平），因为该算法时间效率高，代码量少，多元性强、灵活度高，主要考察思维能力、建模抽象能力。学了这么久动态规划，虽然还只是个菜菜= =，但还是想总结一下，总得给学弟学妹留下一些
背包九讲2.0_算法_动态规划_ACM_
10-02
在ACM竞赛中，动态规划常用于解决背包问题、最长公共子序列、旅行商问题等经典题目。 1. **动态规划基础**：动态规划的核心思想是“最优子结构”和“重叠子问题”。书中首先介绍了动态规划的基本概念，如何构建状态...
ACM.rar_ACM算法_动态规划
最新发布
09-22
动态规划的应用场景多种多样，包括但不限于背包问题、最长公共子序列、最小编辑距离、最短路径等。在描述中提到的“最短路”问题，就是动态规划的一个经典应用。例如，Dijkstra算法和Floyd-Warshall算法可以用来找到...
DP.rar_ACM_动态规划
09-21
总的来说，动态规划是一种解决复杂问题的有效工具，通过深入理解和实践，不仅能够提高在ACM等编程竞赛中的竞争力，还能对算法设计和优化有着深远的影响。在实际工作中，DP也被广泛应用在诸如网络路由、资源分配、...
ACM新手DAY 26 计算几何
listening~的博客
08-12 683
题解 A - TOYS 题目：给出多个区间和多个点，计算每个区间包括的点的数目 计算几何+搜索 判断点与线段的位置关系+二分搜索（先用二分搜索找到点大概的位置，然后用点与线段的判断找到精确位置） //点在线段之间+二分查找 #include<iostream> #include<cstdio> #include<string.h> using names...
ACM新手DAY 4 DFS及其应用
listening~的博客
07-17 561
题解 A - 迷宫问题 用DFS解决迷宫问题。直接代码分析 #include <iostream> #include <vector> #include <string.h> using namespace std; int m(5),n(5); int vis[20][20];//标记数组，去掉已经经过的地点 int f[4][2] = {{0,-1},{-...
ACM新手DAY 24 倍增与树上倍增
listening~的博客
08-09 342
题解 D - Misha, Grisha and Underground 题目：一棵树，给三个节点，求它们间一个点到其余两个点路径的公共路径上经过节点数的最大值。 如果这三个整数构成了这样的两个路径，a到b，和，c到b 这两个路径。定义a到b的距离是lab，其他类推。那么这两个路径的交点个数是 ( lab + lbc - lac ) / 2 + 1那么用倍增在线LCA求任意两个节点的最短路径...
ACM新手DAY 6 最短路径
listening~的博客
07-21 295
题解 A - 最短路 以本题为模板做的讲解，直接放上代码，这个是Dijkstra（迪杰斯特拉）算法。 Dijkstra算法步骤 初始化： 1、将源点v0加到S中，即S[v0] = true； 将v0到各个终点的最短路径长度初始化为权值，即D[i] = G.arcs[v0][vi]，(vi∈V − S)； 如果v0和顶点vi之间有弧，则将vi的前驱置为v0，即Path[i] = v0，否则Path[...
ACM算法模板：动态规划与背包问题解析
"ACM算法模板合集包含了ACM竞赛中常见的算法模板，如动态规划、最长公共子序列以及背包问题的解决方案。" 在ACM算法竞赛中，掌握高效的算法和模板是至关重要的。以下是对这些算法的详细解释： 1. **动态规划...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值