《挑战程序设计竞赛》2.3 动态规划-基础 POJ3176 2229 2385 3616 3280

最新推荐文章于 2019-05-12 20:29:52 发布
最新推荐文章于 2019-05-12 20:29:52 发布
阅读量107 收藏
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：http://www.cnblogs.com/liangrx06/p/5083766.html
版权

POJ3176

Cow Bowling

题意

输入一个n层的三角形，第i层有i个数，求从第1层到第n层的所有路线中，权值之和最大的路线。
规定：第i层的某个数只能连线走到第i+1层中与它位置相邻的两个数中的一个。

思路

最显而易见的是使用二维数组动态规划计算。
比如dp[i][j]表示以第i行j列的位置作为终点的路线的最大权值。 （注意区分初始化时的意义）
那么dp[i][j]的最大值取决于dp[i-1][j-1]和dp[i-1][j]，从这两者之间筛选出最大值，加到dp[i][j]上，即为dp[i][j]的最大权值。
最后只要比较第n行中所有位置的权值dp[n][j],最大的一个即为所求。
但其实用一维数组也能够完成要求，具体请看我的代码。

代码

Source Code

Problem: 3176       User: liangrx06
Memory: 248K        Time: 79MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 350;

int main(void)
{
    int n;
    int a[N], dp[N];

    cin >> n;
    dp[0] = 0;
    for (int i = 0; i < n; i ++) {
        for (int j = 0; j <= i; j ++) {
            scanf("%d", &a[j]);
        }
        for (int j = i; j >= 0; j --) {
            if (j == 0)
                dp[j] = dp[j] + a[j];
            else if (j == i)
                dp[j] = dp[j-1] + a[j];
            else
                dp[j] = max(dp[j], dp[j-1]) + a[j];
        }
    }

    int sum = 0;
    for (int i = 0; i < n; i ++)
        sum = max(dp[i], sum);
    printf("%d\n", sum);

    return 0;
}

POJ2229

Sumsets

题意

求把一个整数分解为2的幂的和共有几种方案。
例如整数7的分解有6种方案：
7=1+1+1+1+1+1+1
7=1+1+1+1+1+2
7=1+1+1+2+2
7=1+1+1+4
7=1+2+2+2
7=1+2+4

思路

这种题通常都是用递归来解的。假设n对应的分解方案数为f(n)首先按照n为奇数和偶数的情况分别分析：
n为奇数时，分解式中一定含有1，去掉这个1，剩下的分解式的和为n-1，也就是说，f(n) = f(n-1)；
n为偶数时，分解式中若含有1，方案数为f(n-1)，若不含有1，将分解式中的数都除以2，其和对应于n/2，也就是说方案数为f(n/2)，所以f(n) = f(n-1)+f(n/2)。
如此由n=1的初始条件递归求解即可，也可以说是动态规划。
但是这个题我WA了三次，后来发现这个题的答案会超出long long的表示范围，需要取余，改了好几次才AC。所以一定要注意答案的范围。

代码

Source Code

Problem: 2229       User: liangrx06
Memory: 4136K       Time: 125MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 1000000;

int main(void)
{
    int n;
    int a[N+1];

    cin >> n;
    a[0] = 1;
    for (int i = 1; i <= n; i ++) {
        if (i&1)
            a[i] = a[i-1];
        else
            a[i] = a[i/2] + a[i-1];
        a[i] %= 1000000000;
    }
    printf("%lld\n", a[n]);

    return 0;
}

POJ2385

Apple Catching

题意

2棵苹果树在T分钟内随机由某一棵苹果树掉下一个苹果，奶牛站在树#1下等着吃苹果，它最多愿意移动W次，问它最多能吃到几个苹果。

思路

动态规划题。状态空间主要决定于W，以dp[i][j][k]表示第i+1分的时候经过j次移动站在了k+1树下能吃到的最大苹果数，然后搜索所有的ijk组合，更新dp。
实际上我使用的数组是dp[i&1][j][k]，用i&1的目的是降低空间复杂度，dp数组大小降为原来的2/T。

代码

Source Code

Problem: 2385       User: liangrx06
Memory: 248K        Time: 16MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int T = 1000;
const int W = 30;

int main(void)
{
    int t, w;
    int a[T+1];
    int dp[2][W+1][2];

    cin >> t >> w;
    memset(dp, 0, sizeof(dp));
    for (int i = 1; i <= t; i ++) {
        scanf("%d", &a[i]);
        a[i] --;
        for (int j = 0; j <= w; j ++) {
            dp[i&1][j][a[i]] = dp[(i-1)&1][j][a[i]] + 1;
            dp[i&1][j][(a[i]+1)&1] = dp[(i-1)&1][j][(a[i]+1)&1];
            if (j > 0) {
                dp[i&1][j][a[i]] = max(dp[i&1][j][a[i]],
                        dp[(i-1)&1][j-1][(a[i]+1)&1] + 1);
                dp[i&1][j][(a[i]+1)&1] = max(dp[i&1][j][(a[i]+1)&1],
                        dp[(i-1)&1][j-1][a[i]]);
            }
        }
    }
    int res = 0;
    for (int j = 0; j <= W; j ++) {
        res = max(res, dp[t&1][j][0]);
        res = max(res, dp[t&1][j][1]);
    }
    printf("%d\n", res);

    return 0;
}

POJ3616

Milking Time

题意

奶牛Bessie在0~N时间段产奶。农夫约翰有M个时间段可以挤奶，时间段f,t内Bessie能挤到的牛奶量e。奶牛产奶后需要休息R小时才能继续下一次产奶，求Bessie最大的挤奶量。

思路

定义dp[i]表示第i个时间段（注意此处的第i个时间段不等同于第i次）挤奶能够得到的最大值，拆开来说，就是前面 i – 1个时间段任取0到i – 1个时间段挤奶，然后加上这个时间段（i）的产奶量之和。
dp[i]满足如下递推关系：
第i个时间段挤奶的最大值 = 前 i – 1 个时间段挤奶的最大值的最大值 + 第i次产奶量。

代码

Source Code

Problem: 3616       User: liangrx06
Memory: 184K        Time: 0MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

const int M = 1000;

struct Time {
    int f, e, v;
};

bool cmp(const Time& a, const Time& b)
{
    return a.f < b.f;
}

int main(void)
{
    int n, m, r;
    Time t[M];
    int dp[M+1];
    int ans = 0;

    scanf("%d%d%d", &n, &m, &r);
    for (int i = 0; i < m; i ++)
        scanf("%d%d%d", &t[i].f, &t[i].e, &t[i].v);
    sort(t, t+m, cmp);

    memset(dp, 0, sizeof(dp));
    for (int i = 0; i < m; i ++) {
        dp[i] = t[i].v;
        for (int j = 0; j < i; j ++) {
            if (t[i].f >= t[j].e + r)
                dp[i] = max(dp[i], dp[j] + t[i].v);
        }
        ans = max(ans, dp[i]);
    }
    printf("%d\n", ans);

    return 0;
}

POJ3280

Cheapest Palindrome

题意

有一个由n个小写字母组成的，长度为m的字符串，可以对其通过增加字符或者删除字符来使其变成回文。而增加或者删除字符都有一个花费，求解使该字符串变成回文的最小花费。

思路

动态规划。dp[i][j]表示串str[i~j]变成回文的最小代价，故状态转移方程为：
当str[i] == str[j]时 dp[i][j] = dp[i+1][j-1];
当str[i] != str[j]时 dp[i][j] = min( dp[i+1][j]+add[str[i]-'a'], dp[i][j-1]+add[str[j]-'a'], dp[i+1][j]+del[str[i]-'a'], dp[i][j-1]+del[str[j]-'a']);

更详细的分析（以下内容转自小鱼的博客）：

其实dp很难逃出3种思路：
1、一维线性dp：每次考虑i时，选择最优子问题要么在i-1，要么在1...i-1里；
2、二维线性dp：考虑(i,j)子问题时，选择最优子问题要么在(i+1,j)、(i,j-1)，要么在i<= k <=j，在k里；
3、树形dp：考虑i节点最优时，选择子节点最优，一般融合了01背包dp的双重dp。
上面3种模式也是我在做题后才发现的。
这个dp题其实就可以仿照第2中思路。
假设一个字符串Xx....yY；对于求这个字符串怎么求呢？
分4种情况讨论：
1、去掉X，取x....yY回文；
2、去掉Y，取Xx....y回文；
3、在左边加上X,取Xx....yYX回文；
4、在右边加上Y,取YXx....y回文。
至于去掉X、Y肯定没有第1、2中情况合算；加上X、Y肯定没有第3、4中情况合算。
因此令dp[i][j]为i...j要变成回文字符串的最小代价。
方程：
dp[i][j] = min{  dp[i+1][j] + {去掉X的代价}，dp[i+1][j] + {加上X的代价}，dp[i][j-1]+ {去掉Y的代价}，dp[i][j-1] +{加上Y的代价}}；
其实分析发现，对于X而言，只要去 去掉 和加上 X 最小代价就行（因为前面dp串一样）,Y同理。
因此最后得出：
dp[i][j] = min{  dp[i+1][j] +min{ {去掉X的代价}, {加上X的代价}}，dp[i][j-1]+min{ {去掉Y的代价}, {加上Y的代价}}}；
dp时候还有些注意事项：
比如当X和Y字符一样时，则在dp时必须先为x...y的最小代价。

代码

Source Code

Problem: 3280       User: liangrx06
Memory: 15852K      Time: 172MS
Language: C++       Result: Accepted
Source Code
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int M = 2000;

int dp[M+1][M+1];

int main(void)
{
    int i, j, k, n, m;
    char s[M+1];
    int add[26], del[26];

    scanf("%d%d%s", &n, &m, s);
    for (i = 0; i < n; i ++) {
        char c[2];
        scanf("%s", c);
        scanf("%d", &add[c[0]-'a']);
        scanf("%d", &del[c[0]-'a']);
    }

    memset(dp, 0, sizeof(dp));
    for (k = 0; k < m; k ++) {
        for (i = 0; i < m-k; i ++) {
            j = i + k;
            if (s[i] == s[j])
                dp[i][j] = dp[i+1][j-1];
            else {
                dp[i][j] = min(dp[i+1][j] + add[s[i]-'a'], dp[i+1][j] + del[s[i]-'a']);
                dp[i][j] = min(dp[i][j], dp[i][j-1] + add[s[j]-'a']);
                dp[i][j] = min(dp[i][j], dp[i][j-1] + del[s[j]-'a']);
            }
        }
    }
    printf("%d\n", dp[0][m-1]);

    return 0;
}

转载于:https://www.cnblogs.com/liangrx06/p/5083766.html

weixin_30608131
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
POJ 3176-Cow Bowling [dp] 《挑战程序设计竞赛》2.3
yoer77的博客
04-04 246
题目链接： POJ-Cow Bowling题目大意： 一个三角矩阵， 比如： 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 从三角形的顶端往下沿着对角线走，直到走到底部。求这样一条路径经过的点的分数之和的最大值。 ， 输入格式： 第一行一个NN 接下来NN行每行就是三角矩阵的一层
POJ 2393-Yogurt factory [贪心] 《挑战程序设计竞赛》2.2
yoer77的博客
04-04 388
题目链接： POJ 2393-Yogurt factory 题目大意： 酸奶厂造酸奶，每天的原料，工资成本都不同，占单位酸奶的百分之cic_i , 每天的需求量也不同，为yiy_i 。这个酸奶厂很厉害， 只要你想， 它一天可以造出无限的酸奶。酸奶厂还有个巨大无比容量无限的仓库， 可以用来存放没用完的酸奶。每天的存储费用都是一个常数， 单位酸奶的百分之SS 。现在给定了NN 天的成本和需求，求每天
动态规划整理综合一下(挑战程序设计竞赛)
甜晨流年
10-25 367
题目：有n个重量和价值分别为wi,vi的物品。从这些物品中挑选出总重量不超过W的物品，求所有挑选方案中价值总和的最大值。 题目的限制条件： 1） 1&lt;=n&lt;=100 2)    1&lt;=wi,vi&lt;=100 3)    1&lt;=W&lt;=10000 样例输入： n = 4 (w,v) = { (2,3), (1,2), (3,4), (2,2) } W ...
[动态规划] 能量苹果问题
weixin_30951231的博客
08-31 109
Maximum Energy Time Limit:1000MS Memory Limit:32768K Description: Bobwanted to increase his energy by eating AC-APPLEs. There are N(1 <= N <= 150,000) AC-APPLEs, each AC-APPLE had a magi...
《挑战程序设计竞赛》2.1 穷竭搜索 POJ2718 POJ3187 POJ3050 AOJ0525
weixin_30819163的博客
12-13 108
POJ2718 Smallest Difference Time Limit:1000MS Memory Limit:65536K Total Submissions:6509 Accepted:1773 Description Given a number of distinct decimal d...
程序设计导引及在线实践 POJ
05-14
程序设计导引及在线实践
挑战程序设计竞赛（第2版）
08-05
本书对程序设计竞赛中的基础算法和经典问题进行了汇总，分为准备篇、初级篇、中级篇与高级篇4章。作者结合自己丰富的参赛经验，对严格筛选的110 多道各类试题进行了由浅入深、由易及难的细致讲解，并介绍了许多实用...
NOIP NOI 信息学竞赛 ACM-ICPC POJ（北京大学在线评测系统）刷题推荐 OI复习计划 算法大纲
10-04
包含15类的POJ推荐50题，可全面复习或学习算法。 除此外还包含三种级别的水平（初级、中级、高级）应掌握的算法及数据结构及... (poj3096,poj3007)(2)较为复杂的模拟题的训练(poj3393,poj1472,poj3371,poj1027,poj2706)
北大POJ初级-动态规划
07-31
北大POJ初级-动态规划 解题报告+AC代码
POJ.rar_C++_oj_本科_程序设计实习
09-24
大一程序设计实习练习题 Openjudge经典题目
《挑战程序设计竞赛》 P191 旅行商问题（货担郎） 状态压缩
登山望远海 立马定中原
12-20 456
样例 5  8 0 1 3 0 3 4 1 2 5 2 0 4 2 3 5 3 4 3 4 0 7 4 1 6 输出： 22
POJ 1163 The Triangle【dp+杨辉三角加强版(递归)】
weixin_34026276的博客
07-17 110
The Triangle Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 49955   Accepted: 30177 Description 73 88 1 02 7 4 44 5 2 6 5(Figure 1) Fig...
1060-接苹果
weixin_30329623的博客
11-22 181
描述 很少有人知道奶牛爱吃苹果。农夫约翰的农场上有两棵苹果树（编号为1和2）， 每一棵树上都长满了苹果。奶牛贝茜无法摘下树上的苹果，所以她只能等待苹果 从树上落下。但是，由于苹果掉到地上会摔烂，贝茜必须在半空中接住苹果（没有人爱吃摔烂的苹果）。贝茜吃东西很快，她接到苹果后仅用几秒钟就能吃完。每一分钟，两棵苹果树其中的一棵会掉落一个苹果。贝茜已经过了足够的训练， 只要站在树下就一定能接住这棵...
挑战程序设计竞赛笔记-动态规划
weixin_38774779的博客
05-12 164
2.3.1 记忆化搜索与动态规划
poj 3176
一颗平常心
05-28 195
大致题意： 输入一个n层的三角形，第i层有i个数，求从第1层到第n层的所有路线中，权值之和最大的路线。 规定：第i层的某个数只能连线走到第i+1层中与它位置相邻的两个数中的一个。 解题方法： 用二维数组way[][]靠左存储三角形内的数据，那么连线规则变更为 way[i][j] → Way[i+1][j] 或 Way[i][j] → Way[i+1][j+1]   注意：w...
POJ 3176 Cow Bowling
Waves___的博客
08-02 237
/* 输入一个n层的三角形，第i层有i个数， 求从第1层到第n层的所有路线中，权值之和最大的路线。 规定：第i层的某个数只能连线走到第i+1层中与它位置相邻的两个数中的一个。 就是一个数塔 dp[i][j] += max(dp[i+1][j], dp[i+1][j+1]); 7 3 8 8 1 0 2 7 4 4 4 5 2
【2014.8.17NOIP普及组模拟】接苹果//2018.2.3 {动态规划}
Nowed
02-04 548
题目 题目描述 很少有人知道奶牛爱吃苹果。农夫约翰的农场上有两棵苹果树（编号为1和2），每一棵树上都长满了苹果。奶牛贝茜无法摘下树上的苹果，所以她只能等待苹果从树上落下。但是，由于苹果掉到地上会摔烂，贝茜必须在半空中接住苹果（没有人爱吃摔烂的苹果）。贝茜吃东西很快，所以她接到苹果后仅用几秒钟就能吃完。 ​ 每一分钟，两棵苹果树其中的一棵会掉落一个苹果。贝茜已经过了足够的训练，只
动态规划问题学习路线：斐波那契数列，最大递增子序列，松鼠捡苹果，最大公共子序列，字符串编辑距离
qq632544991p的专栏
09-04 2172
基本思想：若要解一个给定问题，我们需要解其不同部分（即子问题），再合并子问题的解以得出原问题的解。 通常许多子问题非常相似，为此动态规划法试图仅仅解决每个子问题一次，从而减少计算量： 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。 这种做法在重复子问题的数目关于输入的规模呈指数增长时特别有用。 核心：记忆化搜索与递归 下面来看几个具体的问题，由浅
挑战程序设计(算法和数据结构)—动态规划（DP）
Accept1234的博客
02-12 314
文章目录斐波那契数列最长公共子列（LCS）硬币问题 斐波那契数列 题目11.2链接Fibonacci Number 解决斐波那契数列有三种方法 1&amp;amp;amp;amp;amp;amp;gt;直接递归 fib(n) if n==0 || n==1 return 1 return fib(n-1)+fib(n-2) 2&amp;amp;amp;amp;amp;amp;gt;记忆化递归 fib(n) if n==0 || n==1 return
POJ - 3616
最新发布
09-18
POJ - 3616是一个题目，题目描述如下： 给定一组区间，每个区间有一个权重，要求选择一些区间，使得这些区间的右端点都小于等于k，并且权重之和最大。请问最大的权重和是多少？ 解决这个问题的思路是使用动态规划。首先，将区间按照左端点从小到大进行排序。然后，定义一个dp数组，dp[i]表示右端点小于等于i的所有区间所能得到的最大权重。 接下来，遍历每一个区间，对于每个区间i，将dp[i]初始化为区间i的权重。然后，再遍历i之前的每个区间j，如果区间j的右端点小于等于k，并且区间j的权重加上区间i的权重大于dp[i]，则更新dp[i]为dp[j]加上区间i的权重。 最后，遍历整个dp数组，找到最大的权重和，即为所求的答案。 下面是具体的代码实现： ```cpp #include <cstdio> #include <cstring> #include <algorithm> using namespace std; struct interval{ int start, end, weight; }; interval intervals[10005]; int dp[10005]; int n, m, k; bool compare(interval a, interval b) { if (a.start == b.start) { return a.end < b.end; } else { return a.start < b.start; } } int main() { while(~scanf("%d %d %d", &n, &m, &k)) { memset(dp, 0, sizeof dp); for (int i = 0; i < m; i++) { scanf("%d %d %d", &intervals[i].start, &intervals[i].end, &intervals[i].weight); } sort(intervals, intervals + m, compare); for (int i = 0; i < m; i++) { dp[i] = intervals[i].weight; for (int j = 0; j < i; j++) { if (intervals[j].end <= k && dp[j] + intervals[i].weight > dp[i]) { dp[i] = dp[j] + intervals[i].weight; } } } int maxWeight = 0; for (int i = 0; i < m; i++) { maxWeight = max(maxWeight, dp[i]); } printf("%d\n", maxWeight); } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值