DP简单题

最新推荐文章于 2022-01-01 21:38:19 发布
最新推荐文章于 2022-01-01 21:38:19 发布
阅读量643 收藏
点赞数
分类专栏： POJ ~~~~~~~~~~动态规划 文章标签： ACM dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014355480/article/details/47128453
版权

The Triangle

题目传送：The Triangle

TLE代码（递归形式的DP）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 105;

int a[maxn][maxn];
int n;

int max_sum(int x, int y) {
    if(x == n) {
        return a[x][y];
    }
    else {
        return max(max_sum(x+1, y), max_sum(x+1, y+1)) + a[x][y];
    }
}

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 1; i <= n; i ++) {
            for(int j = 1; j <= i; j ++) {
                scanf("%d", &a[i][j]);
            }
        }

        cout << max_sum(1, 1) << endl;
    }
    return 0;
}

上面代码会超时，因为重复计算，复杂度高达O(2n)，这里为了避免TLE，可以用一个辅助数组存储每一次计算出来的maxSum，因为记录了是否访问过，所以称为记忆化搜索，复杂度为O(n2)

AC代码（优化后的记忆化搜索）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 105;

int maxSum[maxn][maxn];//maxSum[i][j]代表从最底部到第i层第j个可以达到的最大值 
int a[maxn][maxn];
int n;

int max_sum(int x, int y) {
    if(maxSum[x][y] != -1) return maxSum[x][y];//优化，记忆化搜索 
    if(x == n) {
        maxSum[x][y] = a[x][y];
    }
    else {
        maxSum[x][y] = max(max_sum(x+1, y), max_sum(x+1, y+1)) + a[x][y];
    }
    return maxSum[x][y];
}

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 1; i <= n; i ++) {
            for(int j = 1; j <= i; j ++) {
                scanf("%d", &a[i][j]);
                maxSum[i][j] = -1;
            }
        }

        cout << max_sum(1, 1) << endl;
    }
    return 0;
}

上面还是递归形式的DP，我们可以进一步改为递推形式的DP

AC代码（改为递推形式的DP）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 105;

int a[maxn][maxn];
int maxSum[maxn][maxn];//maxSum[i][j]代表从最底部到第i层第j个可以达到的最大值 
int n;

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 1; i <= n; i ++) {
            for(int j = 1; j <= i; j ++) {
                scanf("%d", &a[i][j]);
            }
        }

        for(int i = 1; i <= n; i ++) {
            maxSum[n][i] = a[n][i];
        }

        for(int i = n-1; i >= 1; i --) {
            for(int j = 1; j <= i; j ++) {
                maxSum[i][j] = max(maxSum[i+1][j], maxSum[i+1][j+1]) + a[i][j];
            }
        }

        cout << maxSum[1][1] << endl;
    }
    return 0;
}

空间优化，其实可以不用maxSum数组的，因为a数组完全可以代替它

AC代码（优化了空间的DP）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 105;

int a[maxn][maxn];
int n;

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 1; i <= n; i ++) {
            for(int j = 1; j <= i; j ++) {
                scanf("%d", &a[i][j]);
            }
        }

        for(int i = n-1; i >= 1; i --) {
            for(int j = 1; j <= i; j ++) {
                a[i][j] = max(a[i+1][j], a[i+1][j+1]) + a[i][j];
            }
        }

        cout << a[1][1] << endl;
    }
    return 0;
}


最长上升子序列

题目传送：2757:最长上升子序列

AC代码（复杂度O(n2)）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 1005;

int n;
int a[maxn];
int maxLen[maxn];

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 0; i < n; i ++) {
            scanf("%d", &a[i]);
            maxLen[i] = 1;
        }

        int ans = 1;
        for(int i = 1; i < n; i ++) {
            for(int j = 0; j < i; j ++) {
                if(a[i] > a[j]) {
                    maxLen[i] = max(maxLen[i], maxLen[j] + 1);
                    ans = max(ans, maxLen[i]);
                }
            }
        }

        printf("%d\n", ans);
    }
    return 0;
}

AC代码（复杂度O(n*logn)）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int maxn = 1005;

int n;
int a[maxn];
int g[maxn];

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 0; i < n; i ++) {
            scanf("%d", &a[i]);
        }

        for(int i = 0; i < n; i ++) g[i] = INF;

        int ans = 0;
        for(int i = 0; i < n; i ++) {
            int k = lower_bound(g, g + n, a[i]) - g;
            g[k] = a[i];
            ans = max(ans, k + 1);
        }

        printf("%d\n", ans);
    }
    return 0;
}


最长公共子序列

题目传送：Common Subsequence

AC代码（复杂度O(n*m)）：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

char s1[1005];
char s2[1005];

int dp[1005][1005];

int main() {
    while(scanf("%s %s", s1 + 1, s2 + 1) != EOF) {
        int len1 = strlen(s1 + 1);
        int 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;
}


神奇的口袋

题目传送：2755:神奇的口袋

AC代码：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

int n;
int a[25];
int dp[45];//dp[i]表示有多少种不同的选择物品的方式可以达到i 

int main() {
    while(scanf("%d", &n) != EOF) {
        for(int i = 0; i < n; i ++) {
            scanf("%d", &a[i]);
        }
        memset(dp, 0, sizeof(dp));
        dp[0] = 1;//什么都不选的时候也是一种方式 
        for(int j = 0; j < n; j ++) {
            for(int i = 40; i >= 0; i --) {//为了保持当前状态只受上一状态影响，所以使用逆序 
                    dp[i] += dp[i - a[j]];//往前累加所以可能情况 
            }
        }
        printf("%d\n", dp[40]);
    }
    return 0;
}


0-1背包问题

题目传送：Charm Bracelet

AC代码：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

int dp[13000];

int n, m;
int w[3500], d[3500];

int main() {
    while(scanf("%d %d", &n, &m) != EOF) {
        for(int i = 0; i < n; i ++) {
            scanf("%d %d", &w[i], &d[i]);
        }
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < n; i ++) {
            for(int j = m; j >= w[i]; j --) {
                dp[j] = max(dp[j], dp[j-w[i]]+d[i]);
            }
        }
        printf("%d\n", dp[m]);
    }
    return 0;
}


滑雪

题目传送：1088:滑雪

AC代码：

#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <cstdio>
#include <cctype>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define INF 0x7fffffff
using namespace std;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};

int r, c;
int dp[105][105];
int h[105][105];

struct Pos {
    int x, y;
    int h;
    bool operator < (const Pos a)const {
        return h < a.h;
    }
}p[10005];
int cnt;

/*
bool operator < (const Pos a, const Pos b) {
    return a.h < b.h;
}
运算符重载函数，用于结构体的比较，可以写在结构体里面，也可以写外面，不过注意两种写法的不同 
*/

/* 
bool cmp(Pos a, Pos b) {
    return a.h < b.h;
}
也用于结构体的比较，不过调用sort函数时要改一下写法，本题可以写成sort(p, p + r * c, cmp);
*/

int main() {
    while(scanf("%d %d", &r, &c) != EOF) {
        cnt = 0;
        for(int i = 1; i <= r; i ++) {
            for(int j = 1; j <= c; j ++) {
                scanf("%d", &h[i][j]);
                p[cnt].x = i;
                p[cnt].y = j;
                p[cnt ++].h = h[i][j];
                dp[i][j] = 1;
            }
        }

        sort(p, p + r * c);

        int ans = 0;
        for(int i = 0; i < r * c; i ++) {
            int x = p[i].x;
            int y = p[i].y;
            for(int j = 0; j < 4; j ++) {
                int xx = x + dx[j];
                int yy = y + dy[j];
                if(xx >= 1 && xx <= r && yy >= 1 && yy <= c && h[xx][yy] < h[x][y]) {
                    dp[x][y] = max(dp[x][y], dp[xx][yy] + 1);
                }
            }
            ans = max(ans, dp[x][y]);
        }

        printf("%d\n", ans);
    }
    return 0;
}
zzuspy
关注
专栏目录
DP 套 DP
EricQian的博客
04-25 365
DP 套 DP 学习笔记 大致内容 DP 套 DP 就是将一个简单 DP 的状态压缩起来放到新的 DP 中当做状态进行 DP 的过程。 常用于计算简单 DP 的答案为 \(k\) 的转移方案的数量。 一般都需要 decode 和 recode 操作，这里和 插头DP/轮廓线DP 有异曲同工之妙！ 例题 P4590 [TJOI2018]游园会 按照以前的套路来，设 \(dp(i,j,p)\) 表示...
poj 2411（插头DP 简单题）
志当存高远
05-17 3210
Mondriaan's DreamTime Limit: 3000MS Memory Limit: 65536K Total Submissions: 5930 Accepted: 3414 Description Squares and rectangles fascinated the famous Dutch painter Piet Mondriaan. One night,
一些简单的DP题
Aetherrrr的博客
08-19 402
一、01背包问题 (先枚举物品，再逆序枚举容量) 1、Hdu 2602 Bone Collector 非常常规的01背包问题，用一维和二维数组都可以做，一维快相当多。 2、Poj 3624 Charm Bracelet 赤裸裸的01背包问题 3、Hdu 2546 饭卡 n种菜选若干种使剩下的钱最少，背包容量是开始时的钱，物品体积是菜的价格，状态转移时记录答案。 4、Uva 624 CD 常规的0...
简单dp及例题
qq_45533673的博客
02-14 513
简单动态规划及其基础例题 dp Dynamic Programming是算法的设计方法，是一种编程思想，是用前面的子状态来推导出后面的状态的一种方式。主要用于解决最优解类型的问题。 对于这类问题，需要注意，每个子状态都必须是最优的，才能用来推导后面的最优。也就是说，其基本思想是：将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。 例1 矩形取数问题 一个N*N矩阵中有不同的正...
简单DP题集
柯微
11-21 176
参考博客：https://www.cnblogs.com/letlifestop/category/1382346.html 简单的dp问题：找是否有重叠问题，明确递推关系，如何推（顺序千万不要搞错），找到状态方程，循环时注意边界条件和方程式是否严格成立。 A.Ayoub and Lost Array（简单DP） B.Easy Problem（简单DP） C.数塔 HDU - 2084 ...
几道简单dp题目。
叶子心情你不懂
02-07 944
两道DP后打印的： 一。劲歌金曲（Jin Ge Jin Qu [h]ao, Rujia Liu's Present 6, UVa 12563） 题目描述： (If you smiled when you see the title, this problem is for you ^_^) For those who don’t know KTV, see: http://en.wikip
【题目记录】——DP简单题
气派飞鹰的博客
10-29 253
文章目录POJ1837 Balance DP POJ1837 Balance DP 题目地址:POJ1837 Balance 题目大意： 有一个天平，天平左右两边各有若干个钩子，总共有C个钩子，有G个钩码，求将钩码全部挂到钩子上使天平平衡的方法的总数。 思路：其实一开始我也没看出来要用DP来做，看了大佬的解释后才明白 每向天平中放一个重物，天平的状态就会改变，而这个状态可以由若干前一状态获得。 定义一个平衡度j的概念,j表示每一个物品所产生的的力矩的和。 当平衡度j=0时，说明天枰达到平衡，j>0，说
新建 WinZip 文件.zip_DP_简单DP不要62
09-19
【标题】"新建 WinZip 文件.zip_DP_简单DP不要62" 涉及到的主要知识点是动态规划（Dynamic Programming, 简称DP）在编程中的应用，特别是针对一个称为"简单DP不要62"的题目。这个题目可能是杭州电子科技大学在线判题...
HDU 3001 Travelling 状态压缩DP简单题
Nicolas
04-19 1450
#include #include #include using namespace std; const int inf = 1000000009; int map[13][13]; int cst[13]; int f[60004][13]; int dp[60004][13]; int n, m; void init() { int i, j; cst[0] = 1; for(i
DP——动态规划入门级教学，什么问题用DP，怎么用DP，三个简单题目帮你理清思路，建立简单DP模板，包教包会
代码之狐的博客
01-01 1036
元旦节，动态规划专题
HDU DP 简单题
05-13 599
横竖分别求一下 最大不连续字段和即可 #include "stdio.h" #include "string.h" int dp[200001]; struct comp { int no,yes; }b[2]; int Max(int a,int b) { if (a<b) return b; else return a; } int main() { int
dp题目整理
The_OIer的博客
05-20 425
一、简单dp 1.1 快速幂优化dp 1.1.1 模板题 斐波那契数列 大家都知道，斐波那契数列是满足如下性质的一个数列： Fn={1                            (n≤2)Fn−1+Fn−2 &
一道经典的dp入门题
菜鸡的学习记录
01-17 804
一道经典的DP题。。。感觉学DP都是从这题开始的。。。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 (Figure 1) Figure 1 shows a number triangle. Write a program that calculates the highest sum of numbers passed on a route ...
刷dp题神器，各类dp题目总表（挖一个坑以后慢慢做）
蒟蒻的博客
06-05 2842
题目列表(标*号的为难度较大的题目) 背包 bzoj2287 poj3093 Bzoj2748 *Bzoj2794 *bzoj1190树形 Bzoj4472 Bzoj1864 *Bzoj4033 *Bzoj3167 *Bzoj4446 状压 Bzoj1087 Bzoj3195 Bzoj4145 *Bzoj1226 *Bzoj2064 *Bzoj4197 数位
简单暴力到dp的优化（入门篇）
少说，多做。
04-16 4815
上篇，我们提到，遇到问题，首先根据定义写出笨方法，找出依赖关系（有些题这一步就不太简单，要自己归纳关系），然后进行优化，下面，我们通过几道此方面的经典的，较为简单的二维题目进行讲解。 开始根据题来说明： 第一个萌新题 给定数组arr, arr 中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张， 再给定一个整数aim 代表要找的钱数，求组成aim ...
算法之动态规划总结（11种DP类型，70道全部搞懂）
热门推荐
pl0321的博客
04-08 4万+
简介 参考文章，将所有的DP问题分成11大类，本文将这些题目的解法进行探讨。所有题目均来自leetcode。 题目 1、线性 DP 最经典单串： 最长上升子序列 最经典双串： 最长公共子序列 经典问题： 三角形最小路径和 最大子序和 乘积最大子数组 鸡蛋掉落（DP+二分） 俄罗斯套娃信封问题 打家劫舍系列: (打家劫舍3 是树形DP) 打家劫舍 打家劫舍 II 股票系列: 买卖股票的最佳时机 买卖股票的最佳时机 II 买卖股票的最佳时机 III 买卖股票的最佳时机 IV
动态规划（DP）经典简单入门题目集
qq_43663263的博客
04-29 1万+
这里写目录标题一、三步问题二、连续数列三、打家劫舍四、不同路径五、最小路径和 一、三步问题 题目链接 我们可以列出一个数组dp[n]，在这个数组中的第i位保存的数据就是上i个楼梯有多少种走法，由此我们可以先得到： dp[1]=1; dp[2]=2; dp[3]=4; 同时我们可以推出状态转移访方程为：dp[i]=(dp[i-1]+dp[i-2]+dp[i-3]) 代码如下： class So...
poj 几道简单的dp题
07-19 218
题目：poj 1836 题意： 求使数列程先递增后递减的形式需要去掉的数字个数。当然也可以直接递减或者只递减不递增。 分析： 用最长递增子序列的方法求，然后枚举两个起点的位置即可。 #include<cstdio> #include<cstring> #include<algorithm> using namespac...
ACM近期之dp学习总结
wcxyky的博客
03-30 399
一.对dp解题的认识 I.理解 初学dp,经过这几天的对于dp的学习，我的简单理解是： 1.做dp的问题首先要搞清楚题意，将一个看似繁琐复杂的问题提取出关键意思转化成可以用简单语言表示的数学题。 2.对于dp动态规划来说，状态转移方程是整个代码的核心，要学会将一个大问题分解成若干个子问题，确定好前后问题联系的状态，进而写出状态转移方程，此外，还要找出边界条件。利用这两点，便构成了解决问题的代码思路...
数位DP入门解析与应用实例
数位DP是解决数位统计问题的有效工具，它通过预处理和状态转移，将复杂问题分解为简单的子问题，从而提高了算法的效率。理解数位DP的基本思想，掌握如何预处理和建立状态转移方程，是解决此类问题的关键。在实际应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值