kuangbin dp基础个人部分总结

最新推荐文章于 2021-08-30 14:52:22 发布
最新推荐文章于 2021-08-30 14:52:22 发布
阅读量214 收藏 2
点赞数
分类专栏： 动态规划 文章标签： ACM   动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44607936/article/details/96319659
版权

主要是一些典型的问题。学艺不精，欢迎指出错误

POJ 2533 Longest Ordered Subsequence（LIS裸题）

题意：略
思路：最长上升子序列（LIS）
状态 d(i)表示以I为结尾的最长上升序列的长度。
转移方程 d(I)=max{0,d(j)|j<I,a[j]<a[I]}+1;

#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1e4+10;
int a[maxn];
int dp[maxn];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=n;i++)
        {
            dp[i]=1;
            for(int j=1;j<i;j++)
            {
                if(a[i]>a[j]&&dp[i]<dp[j]+1)
                    dp[i]=dp[j]+1;
            }
        }
        int ans=0;
        for(int i=1;i<=n;i++)
            ans=max(ans,dp[i]);
        printf("%d\n",ans);
    }
    return 0;
}

HDU 1069 Monkey and Banana(转化LIS)

题意：给n中木块，及其长宽高，每种有无数种，问用这些木块累起来的最高高度。前提是垒在木块上面的木块长宽两维必须小于这个木块
思路：每种木块有六种组合方式（注意不是三种），将六种方式存入结构体，后按照长宽某一维度升序排序，转化为LIS，只不过不是序列长度，而是求序列的和。

#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=30*6+10;
struct node
{
    int lenth;
    int width;
    int height;
}a[maxn];
bool cmp(node a,node b)
{
    if(a.lenth==b.lenth) return a.width<b.width;
    return a.lenth<b.lenth;
}
int dp[maxn];
int main()
{
    int n;
    int cnt=0;
    while(~scanf("%d",&n)&&n)
    {
        for(int i=1;i<=n;i++)
        {
            int x,y,z;//列举六种组合，并存储。
            scanf("%d%d%d",&x,&y,&z);
            a[i*6].lenth=x,a[i*6].width=y,a[i*6].height=z;
            a[i*6-1].lenth=y,a[i*6-1].width=x,a[i*6-1].height=z;
            a[i*6-2].lenth=x,a[i*6-2].width=z,a[i*6-2].height=y;
            a[i*6-3].lenth=z,a[i*6-3].width=x,a[i*6-3].height=y;
            a[i*6-4].lenth=y,a[i*6-4].width=z,a[i*6-4].height=x;
            a[i*6-5].lenth=z,a[i*6-5].width=y,a[i*6-5].height=x;
        }
        sort(a+1,a+1+n*6,cmp);
        for(int i=1;i<=6*n;i++)//O(n平方)的复杂度
        {
            int maxh=a[i].height;
            for(int j=i-1;j>=1;j--)
            {
                if(a[j].lenth<a[i].lenth&&a[j].width<a[i].width)
                    maxh=max(maxh,dp[j]+a[i].height);
            }
            dp[i]=maxh;
        }
        int ans=0;
        for(int i=1;i<=6*n;i++)
            ans=max(ans,dp[i]);
        printf("Case %d: maximum height = %d\n",++cnt,ans);
    }
    return 0;
}

HDU 1160 FatMouse’s Speed（转化为LIS）

题意：从给出的数据中找出尽量多的数据，使它们能排成这样的序列（随着重量的增加，速度在减小），并且输出这个序列。
思路：将老鼠按重量升序排序，转化为速度的LIS问题。pre数组存放路径，最后通过递归输出。注意输出的是老鼠的原序号，结构体num存放老鼠的原序号。

#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
using namespace std;
const int maxn=1e4+10;
struct Mouse
{
    int weight;
    int speed;
    int num;
}m[maxn];
int pre[maxn],dp[maxn];//pre 数组记录路径
bool cmp(Mouse a,Mouse b)
{
    if(a.weight==b.weight) return a.speed>b.speed;
    else return a.weight<b.weight;
}
void print(int x)
{
    if(x==0) return;
    print(pre[x]);
    printf("%d\n",m[x].num); //打印原来的序号
}
int main()
{
    int cnt=0,w,s;
    while(~scanf("%d%d",&w,&s))
    {
        m[++cnt].weight=w;
        m[cnt].speed=s;
        m[cnt].num=cnt;
    }
    sort(m+1,m+1+cnt,cmp);
    for(int i=1;i<=cnt;i++)
    {
        dp[i]=1;
        pre[i]=0;
        for(int j=1;j<i;j++)
        {
            if(m[i].weight>m[j].weight&&m[i].speed<m[j].speed&&dp[i]<dp[j]+1)
            {
                dp[i]=dp[j]+1;
                pre[i]=j;
            }
        }
    }
    int ans=0,pos=0;
    for(int i=1;i<=cnt;i++)
    {
        if(ans<dp[i])
        {
            ans=dp[i];
            pos=i;
        }
    }
    printf("%d\n",ans);
    print(pos);
    return 0;
}

HDU 1074 Doing Homework(状压DP)

初次接触状态压缩，有些地方理解的不够深入。
状态压缩简单来说就是一些状态表示起来很复杂，所以用二进制表示比较方便。
就拿此题来说0 1 1 0 0 0就表示第二种和第三种作业完成，其他未完成的情况。
一些基本的二进制操作
1.判断x二进制第I位是否为1，x&(1<<(I-1)),(判断集合中是否有i元素)
2.将x二进制第I位的0变为1，x|(1<<(I-1)) (将元素i加入到集合)
3.将x二进制第I位的1变为0， x^(1<<(I-1)) (将元素I从集合中删除)
题意：给出n种作业，每种给出截止日期与完成需要的时间。超出截止日期一天上交扣一分，问如何安排作业顺序使扣分最少。
思路：对于每种状态，都能从这种状态去掉一个作业的状态推导过来。T数组存放达到i状态所需的时间，那么再完成一个作业总时间就是T[I]+time[j]。减去截止日期即为扣分，如果x相减小于0，那么就是不扣分。这样转移方程就可以写了。注意，因为答案是倒序输出的，要输出字典序最小的答案，达成每次状态要用的作业字典序要尽量大，所以循环要倒序。

#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
const int inf=0x3f3f3f3f;
int T[(1<<15)+10],pre[(1<<15)+10],dp[(1<<15)+10];
char sub[20][110];
int dead[20],time[20];
void print(int x)
{
    if(!x) return;
    print(x^(1<<(pre[x]-1)));
    printf("%s\n",sub[pre[x]]);
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
            scanf("%s%d%d",sub[i],&dead[i],&time[i]);
        int bit=1<<n;
        for(int i=1;i<bit;i++)
        {
            dp[i]=inf;
            for(int j=n;j>=1;j--)//倒序循环
            {
                if(i&(1<<(j-1)))
                {
                    int tt=i^(1<<(j-1));//没有完成第j个作业的情况
                    int reduce=T[tt]+time[j]-dead[j];
                    reduce=reduce<0?0:reduce;
                    if）(dp[i]>dp[tt]+reduce)
                    {
                        dp[i]=dp[tt]+reduce;
                        pre[i]=j;
                        T[i]=T[tt]+time[j];
                    }
                }
            }
        }
        printf("%d\n",dp[bit-1]);
        print(bit-1);
        memset(pre,0,sizeof(pre));
        memset(T,0,sizeof(T));
    }
    return 0;
}

POJ 2533 Longest Ordered Subsequence（LCS水）

题意：略
思路：最长公共序列问题。dp(I,j)表示a序列，b序列分别截止到I，j对应的最长公共序列。如果a[i]==b[j] 那么dp（i，j）=dp(I-1,j-1)+1;如果不相等，那么a[I]与b[j]必定至少有一个元素不在最长公共序列中，那么dp(I,j)=max{dp(I-1,j),dp(I,j-1)};

#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
char s1[1005],s2[1005];
int dp[1005][1005];
int main()
{
    while(~scanf("%s%s",s1+1,s2+1))
    {
        int len1=strlen(s1+1),len2=strlen(s2+1);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;j++)
            {
                if(s1[i]==s2[j]) dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        printf("%d\n",dp[len1][len2]);
    }
    return 0;
}

HDU 1114 Piggy-Bank(完全背包)

题意：给定一个存钱罐，已知容量。给出n种硬币，每种无限个。用这些硬币恰好装满存钱罐，求出最小值。
思路：完全背包。
主要注意一下初始化问题：

  1. 需要恰好装满，求最大值 f[0]=0,其他为负无穷。
  2. 需要恰好装满，求最小值 f[0]=0,其他为正无穷。
  3. 不需要恰好装满，全部初始化为0。
#include<cstdio>
#include<cstring>
#include<string>
using namespace std;
char s1[1005],s2[1005];
int dp[1005][1005];
int main()
{
    while(~scanf("%s%s",s1+1,s2+1))
    {
        int len1=strlen(s1+1),len2=strlen(s2+1);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=len1;i++)
        {
            for(int j=1;j<=len2;j++)
            {
                if(s1[i]==s2[j]) dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        printf("%d\n",dp[len1][len2]);
    }
    return 0;
}

HDU 1176 免费馅饼

题意 ：中文题面，略；
思路：与数塔问题类似。建立二维数组，dp（i，j）表示从第I秒，j位置开始，能获得的最多馅饼。首先将初始存入。状态需要从后往前推，在最后一秒的状态是确定的就是本身。这一秒的值等于后一秒的最大值加上它的初始值。注意：防止出现-1，整体坐标向右移一个单位 。

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;
int dp[100010][15];
int main()
{
    int n;
    while(~scanf("%d",&n)&&n)
    {
        int maxt=0;
        for(int i=1;i<=n;i++)
        {
            int x,t;
            scanf("%d%d",&x,&t);
            dp[t][x+1]++;//因为j-1可能会出现负值，所以整体将坐标向右移动1个单位
            if(t>maxt) maxt=t;
        }
        //dp[maxt][j] 就是其本身
        for(int i=maxt-1;i>=0;i--)//这一状态需要下一秒的状态推得，所以要倒序
        {
            for(int j=1;j<=12;j++)
            {
                dp[i][j]+=max(max(dp[i+1][j],dp[i+1][j-1]),dp[i+1][j+1]);
            }
        }
        printf("%d\n",dp[0][6]);//整体坐标右移，所以初始位置为6
        memset(dp,0,sizeof(dp));
    }
    return 0;
}

HDU 1260 Tickets

题意：一队人买电影票，可以自己买，也可以和相邻的人一块买。自己买和与相邻的人一块买的时间都会给出。问最少多长时间能全部买完。
思路：对于一个人，可以分为两种情况，自己买和与左边的人一块买两种情况，去最小值即可。
时间处理见代码。

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;
int a[2010],b[2010];
int dp[2010];
int main()
{
    int n;
    scanf("%d",&n);
    while(n--)
    {
        memset(dp,0,sizeof(dp));
        int k;
        scanf("%d",&k);
        for(int i=1;i<=k;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=k-1;i++)
            scanf("%d",&b[i]);
        dp[1]=a[1];
        for(int i=2;i<=k;i++)
        {
            dp[i]=min(dp[i-2]+b[i-1],dp[i-1]+a[i]);//两种情况，相邻买或自己买
        }
        //printf("%d\n",dp[2]);
        int h=dp[k]/3600;
        int m=(dp[k]%3600)/60;
        int s=(dp[k]%3600)%60;
        if(h+8<=12) printf("%02d:%02d:%02d am\n",8+h,m,s);
        else printf("%02d:%02d:%02d pm\n",8+h-12,m,s);
    }
    return 0;
}
lasomisolaso~
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kuangbin 基础DP集合
qq_40921866的博客
02-16 141
HDU 1024第一遍水过，没有体会到这个题的奥妙，思考了很久终于体会了。大概意思是求把序列分成m段的子序列，并不一定要覆盖完，求子序列和的最大值我们首先要写出基本的动态转移方程： DP:dp[ i ] [ j ] =max ( dp[ i - 1 ] [ 1~j-1 ]+a[ j ],dp[ i ] [ j - 1 ]+a[ j ] ) 其中dp[ i ][ j ]其中i,...
Kuangbin带你飞 基础DP专题
killers_999的博客
04-23 261
bin神的DP专题真的有好多啊，整理一下做过的基础DP专题。 HDU1029Ignatius and the Princess IV http://acm.hdu.edu.cn/showproblem.php?pid=1029 题意 给出n，和n个数，找出至少出现(n+1)/2次的数字。 思路 至少出现(n+1)/2次，如果这个数存在那么排序后位于中间位置的一定是这个特殊的数。 H...
【kuangbin带你飞基础DP专题】 简要题解
lajiyuan的博客
08-30 1622
biubiubiu第一次尝试一天rush一套专题（由于这套简单一些），14个小时完成了，现在来补一下当时卡住的题或者比较有意思的题的题解。 按照AC人数写一下题解 HDU1029 http://acm.hdu.edu.cn/showproblem.php?pid=1029 这个题是一个非常经典的裁判官问题，有o(n)时间o(1)空间的解法，原理是根据如果这个数列中存在一个出现次数超...
kuangbin专题十二基础dp总结
qq_34921856的博客
03-19 894
做这个专题的时候感觉好迷。一度被题恶心到了。。 这题把所有不是独立思考做出来的题贴出来吧。 A - Max Sum Plus Plus 题解:dp[i][j] 代表前i个数在必须选第i个的前提下组成j组的最大值。 那么方程为: dp[i][j]=max(dp[i-1][j]+a[i],dp[k][j-1]+a[i])(k&lt;=i-1&amp;&amp;k&gt;=j-1). 由于...
kuangbin专题十二 基础dp
qq_43657674的博客
08-30 270
kuangbin专题十二 基础dp 1. Max Sum Plus Plus 压缩一维避免超空间，维护前缀最大值将O(n3)O(n^3)O(n3)降到O(n2)O(n^2)O(n2)。 #include<bits/stdc++.h> using namespace std; const int N=1e6+10,INF=0x7fffffff; int n,m; int a[N],f[N],Max[N]; int main() { while(scanf("%d%d",&m,&am
kuangbin dp 基础DP1
oldz
04-25 493
kuangbin dp 基础DP1 1.Max Sum Plus Plus 这题比较坑，m的取值范围没给，但是O(mn)是可以过的 dp[i,j] = max(dp[i,j-1], max(dp[i-1,k]))+a[i] dp[i,j]，前j个组i组 优化一维 #include &lt;iostream&gt; #include &lt;cstring&gt; #includ...
kuangbin的ACM模板（新）_ACM模板_ACM算法总结_
09-29
《kuangbin的ACM模板（新）》是针对ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）竞赛的一份详细算法总结。这份资料旨在帮助参赛者系统地理解和掌握ACM比赛所需的各类核心算法，...
kuangbin 模板
09-08
kuangbin 模板
kuangbin的ACM模板（2018.7更新）
07-25
kuangbin说他之前的老模板有一些错误，然后这个月分享给了我们新的模板。本来这个东西是公开的免费的，但是上传资源积分至少1个，不支持免费分享。大家如果没有积分的话可以给我私信，我不忙的时候一定会发的~~~欢迎...
kuangbin的ACM模板（新）.pdf
11-15
Contents 1 字符串处理 5 1.1 KMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.2 e-KMP . . . . . . . . . . . . . . . . . . . . . . . . . . ....
kuangbin的ACM模板（新）.zip_kuangbin ACM算法模板
最新发布
09-19
《kuangbin的ACM模板（新）》是一个专门针对ACM（国际大学生程序设计竞赛，International Collegiate Programming Contest）比赛设计的算法模板，由知名程序员kuangbin提供。这个压缩包包含了一份kuangbin的ACM算法...
kuangbin带你飞并查集专题总结
mumei的博客
08-19 369
最近花了一段时间做了kuangbin带你飞并查集专题，今天来做个总结！！！ 并查集本来以为很简单的，做了专题才发现，以前的自己真天真。 并查集，顾名思义：用来快速实现合并，查询集合的操作（缺点：对于把元素提出集合的操作实现不了） 关于最简单的并查集操作和过程，这里也不多说了，大家可以看啊哈算法里面的讲解，既生动又形象。 这里强推几个好的讲解： 【坐在马桶上看算法】啊哈算法13：零基础彻底...
【 题集 】 【kuangbin带你飞】专题十二 基础DP1
Joursion
02-28 1212
B - Ignatius and the Princess IV Time Limit:1000MS     Memory Limit:32767KB     64bit IO Format:%I64d & %I64 Description "OK, you are not too bad, em... But you can never pass the next te
[kuangbin]专题之基础dp | 题解与总结
一只酷酷光儿的博客
09-03 607
由于题目比较多,就只发一下题目意思和思路+代码,最后总结一下. A - Max Sum Plus Plus HDU - 1024 Now I think you have got an AC in Ignatius.L's "Max Sum" problem. To be a brave ACMer, we always challenge ourselves to more...
hdu1176 kuangbin dp专题
HPU WIN
10-28 130
思路：对于dp之类的题来说最重要的就是转移方程的建立吧，在这道题中我们可以得知人要想到达x点，他只能从x+1处，x-1处或者x处原地不动来到达，那么转移方程也就同样建立起来，唯一需要注意的一点大概就是对于0和10这两个临界点的处理。 代码： #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; us...
kuangbin带你飞专题
热门推荐
邵光亮的博客
09-17 14万+
[kuangbin带你飞]专题一 简单搜索 [kuangbin带你飞]专题二 搜索进阶 [kuangbin带你飞]专题三 Dancing Links [kuangbin带你飞]专题四 最短路练习 [kuangbin带你飞]专题五 并查集 [kuangbin带你飞]专题六 最小生成树 [kuangbin带你飞]专题七 线段树 [kuangbin带你飞]专题八 生成树 [ku...
离散化——kuangbin线段树专题总结（2）
qq_37087993的博客
12-17 196
POJ 2528 Mayors’s posters 离散化是线段树中比较常用的一个技巧了 一般这种题题目都会给提示：数据范围很大。。。或者本来就是一种离散的条件，比如说实数轴上的坐标等 离散的话常用到unique函数，比如一个vector或者普通数组里面存了很多坐标，我们先sort一下，再用unique函数去重 unique函数返回的应该是一个指针，指针前面都是去重好的元素，后面是重复的元素 //...
刷题记录 kuangbin带你飞专题一：简单搜索
Raki_J的博客
05-19 534
两天肝完 感觉自己的暴力水平上升了 码力大仙！！！ A.POJ1321 棋盘问题 有一个坑点就是可能相邻层没有棋盘，所以直接搜全部 #include<cstdio> #include<iostream> #include<cstring> #include<string> #include<algorithm> #include<cmath> #include<queue> #include<vector> us
用记忆化搜索解决数位DP的套路总结
Ronaldo7_ZYB的博客
09-03 387
Problem\mathrm{Problem}Problem Problem1\mathrm{Problem}1Problem1 区间[L,R]中每个数码出现的次数。 The Counting Problem——多组询问 ZJOI2007 数字统计——单组询问 Problem2\mathrm{Problem}2Problem2 求区间[L,R]中，在二进制下0的个数比1多的有多少个。 Rou...
算法模板1
08-08
4. **FFT (快速傅立叶变换) - kuangbin模板**: 快速傅立叶变换是离散傅立叶变换的一种高效算法，这里的模板可能涉及将两个数相乘的高效计算，或者在机器人打高尔夫问题中应用。 5. **KMP算法**: KMP算法是一种字符...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值