动态规划的问题总结

最新推荐文章于 2024-01-28 09:45:00 发布
最新推荐文章于 2024-01-28 09:45:00 发布
阅读量186 收藏
点赞数
分类专栏： 算法题 动态规划 文章标签： 动态规划 poj dp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ziqi9216/article/details/73929210
版权

1、dp[个数][weight] (例子：poj 1837 Balance)
dp[i][w]=relate to (dp[i-1][w-c[j]])
这道题中dp存储的不是weight，而是方法个数

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#define MAXNUM 15000
using namespace std;
int dp[25][MAXNUM], C, G, good[25], w[25];
int main()
{
    //freopen("1.txt", "r", stdin);
    int i, j, k, a, b, c, sum, cases;
    scanf("%d%d", &C, &G);
    for (i = 1; i <= C; i++)
        scanf("%d", &good[i]);
    for (i = 1; i <= G; i++)
        scanf("%d", &w[i]);
    dp[0][7500] = 1;
    for (i = 1; i <= G; i++)
    {
        for (j = 0; j <= MAXNUM; j++)
        {
            if (dp[i - 1][j])
            {
                for (k = 1; k <= C; k++)
                    dp[i][j + good[k] * w[i]] += dp[i - 1][j];
            }

        }
    }
    printf("%d\n", dp[G][7500]);
    return 0;
}

2、dp[所有可能的值] (例子：poj 1276 Cash Machine)
if(dp[i]) dp[i+w[t]*k]=1; 有时候Bool类型更好

#include<iostream>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#define CASH 100005
using namespace std;
bool dp[CASH];
int N, cash, n[20], D[20];
int main()
{
    //freopen("1.txt", "r", stdin);
    int i, j, k, a, b, c, res;
    while (scanf("%d%d", &cash, &N) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        memset(n, 0, sizeof(n));
        memset(D, 0, sizeof(D));
        for (i = 0; i < N; i++)
            scanf("%d%d", &n[i], &D[i]);
        if (!N || !cash)
        {
            printf("0\n");
            continue;
        }
        res = 0;
        dp[0] = 1;
        for (i = 0; i < N; i++)
        {
            for (j = res; j >= 0; j--)
            {
                if (dp[j])
                for (k = 1; k <= n[i]; k++)
                {
                    a = j + k*D[i];
                    if (a <= cash)
                    {
                        dp[a] = 1;
                        res = max(res, a);
                    }
                }
            }
        }
        printf("%d\n", res);
    }
    return 0;
}

3、3276 The Cow Lexicon
dp[i]=dp[j]+w[i,j] / dp[i]=dp[j]+w[j,i] 一个是倒着，一个是顺着
dp[i]=dp[i+1]+1 //把这个给删除了
dp[i]=dp[j]+j-i-len //i~j的串删除一些字符后能和Len匹配的

#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<string>
#include<math.h>
using namespace std;
int dp[305], W, L;
char ss[305];
string strs[610];
int main()
{
    //freopen("1.txt", "r", stdin);
    int i, j, k, t, a, b, len, flag;
    while (scanf("%d%d", &W, &L) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        //memset(ss, 0, sizeof(ss));
        scanf("%s", ss);
        for (i = 0; i < W; i++)
            cin >> strs[i];

        for (i = L - 1; i >= 0; i--)
        {
            dp[i] = dp[i + 1] + 1;
            for (j = 0; j < W; j++)
            {
                len = strs[j].length();
                if (len <= L - i&&ss[i] == strs[j][0])
                {
                    int pm = i;
                    int pi = 0;
                    while (pi < len&&pm < L)
                    {
                        if (ss[pm++] == strs[j][pi])
                            pi++;
                        if (pi == len)
                        {
                            dp[i] = min(dp[i], dp[pm] + pm - i - len);
                            break;
                        }
                    }
                }
            }
        }
        printf("%d\n", dp[0]);
    }
    return 0;
}

4 、POJ 1836 Alignment
难一些的最大上升子序列
大神的图

顺着求一次最大上升子序列dpl，倒着求一次最大上升子序列dpr，然后求dpl[i]+dp=i”>j的最大值
(别人的代码，参考博客：http://blog.csdn.net/lin375691011/article/details/11137083)

#include <stdio.h>
#include <string.h>
const int MAX=1005;
int main()
{
    int n,dpl[MAX],dpr[MAX];
    double hi[MAX];
    while(scanf("%d",&n)!=EOF)
    {
        int i,j;
        for(i=0; i<n; i++)
        {
            scanf("%lf",&hi[i]);
        }
        memset(dpr,0,sizeof(dpr));
        memset(dpl,0,sizeof(dpl));
        dpl[0]=1;
        for(i=1;i<n;i++)
        {
            dpl[i]=1;
            for(j=i-1;j>=0;j--)
            {
               if(hi[j]<hi[i]&&dpl[j]+1>dpl[i])
               {
                   dpl[i]=dpl[j]+1;
               }
            }
        }
        dpr[n-1]=1;
        for(i=n-2;i>=0;i--)
        {
            dpr[i]=1;
            for(j=i+1;j<=n-1;j++)
            {
               if(hi[j]<hi[i]&&dpr[j]+1>dpr[i])
               {
                   dpr[i]=dpr[j]+1;
               }
            }
        }
        int ans=dpl[n-1];
        for(i=0;i<n-1;i++)
        {
            for(j=i+1;j<n;j++)
            {
                if(dpl[i]+dpr[j]>ans)
                {
                    ans=dpl[i]+dpr[j];
                }
            }
        }
        printf("%d\n",n-ans);
    }
    return 0;
}

5 、POJ 1260 Pearls
题目有点难懂，懂了之后就是dp[i]=dp[j]+w[i,j]的最小值，遍历j

#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<string>
#include<math.h>
using namespace std;
int price[110], num[110], dp[110], sum[110];
int main()
{
    //freopen("1.txt", "r", stdin);
    int i, j, k, t, tmp, cases;
    scanf("%d", &cases);
    while (cases > 0)
    {
        memset(price, 0, sizeof(price));
        memset(num, 0, sizeof(num));
        memset(sum, 0, sizeof(sum));
        memset(dp, 0, sizeof(dp));
        scanf("%d", &k);
        for (i = 1; i <= k; i++)
        {
            scanf("%d%d", &num[i], &price[i]);
            sum[i] = sum[i - 1] + num[i];
        }

        dp[1] = (num[1] + 10) * price[1];
        for (i = 2; i <= k; i++)
        {
            dp[i] = (num[i] + 10) * price[i] + dp[i - 1];
            for (j = 0; j < i - 1; j++)
            {
                tmp = (sum[i] - sum[j] + 10)*price[i] + dp[j];
                dp[i] = min(dp[i], tmp);
            }
        }
        cases--;
        printf("%d\n", dp[k]);
    }
    return 0;
}

dp 数组的memset很重要！！！！！！！

6 、POJ 1080 Human Gene Functions
编辑距离的变式

#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<string>
#include<math.h>
#define MAXNUM 250
using namespace std;
int dp[MAXNUM][MAXNUM];
char str1[MAXNUM], str2[MAXNUM];
int rep1[MAXNUM], rep2[MAXNUM];
int insert[4] = { -3, -4, -2, -1 };
int contrast[4][4] = { { 5, -1, -2, -1 }, { -1, 5, -3, -2 }, { -2, -3, 5, -2 }, { -1, -2, -2, 5 } };
int main()
{
    //freopen("1.txt", "r", stdin);
    int i, j, k, t, tmp1, tmp2, cases, len1, len2;
    scanf("%d", &cases);
    while (cases > 0)
    {
        memset(rep1, 0, sizeof(rep1));
        memset(rep2, 0, sizeof(rep2));
        memset(dp, 0, sizeof(dp));
        scanf("%d%s", &len1, str1 + 1);
        for (i = 1; i <= len1; i++)
        {
            if (str1[i] == 'A')
                rep1[i] = 0;
            else if (str1[i] == 'C')
                rep1[i] = 1;
            else if (str1[i] == 'G')
                rep1[i] = 2;
            else if (str1[i] == 'T')
                rep1[i] = 3;
        }
        scanf("%d%s", &len2, str2 + 1);
        for (i = 1; i <= len2; i++)
        {
            if (str2[i] == 'A')
                rep2[i] = 0;
            else if (str2[i] == 'C')
                rep2[i] = 1;
            else if (str2[i] == 'G')
                rep2[i] = 2;
            else if (str2[i] == 'T')
                rep2[i] = 3;
        }
        dp[0][0] = 0;
        for (i = 1; i <= len1; i++)
        {
            dp[i][0] = insert[rep1[i]] + dp[i - 1][0];
        }
        for (i = 1; i <= len2; i++)
        {
            dp[0][i] = insert[rep2[i]] + dp[0][i - 1];
        }
        for (i = 1; i <= len1; i++)
        for (j = 1; j <= len2; j++)
        {
            tmp1 = dp[i][j - 1] + insert[rep2[j]];
            tmp2 = dp[i - 1][j] + insert[rep1[i]];
            tmp1 = max(tmp1, tmp2);
            tmp2 = dp[i - 1][j - 1] + contrast[rep1[i]][rep2[j]];
            dp[i][j] = max(tmp1, tmp2);;
        }
        printf("%d\n", dp[len1][len2]);
        cases--;

    }
    return 0;
}

7、poj 1159 Palindrome
这道题我以为是一个字符串和他的反向字符串求编辑距离的问题，但是仔细想想就不对，ab字符串和ba字符串的编辑距离就是2，而实际上需要添加的字符个数其实只有1个，所以仔细想想应该也可以用编辑距离的模板去套用，不过目的是求一个字符串和他的反向字符串得公共最大字符串长度n，然后用字符串的长度L减去n就是最后的结果，比如说Ab3bd与db3bA的公共子串是b3b，为3，5-3=2就为最后的结果。
Accepted 184K 891MS
//这也告诉了我一种新的关于求公共子序列的方法哈哈

#include<iostream>
#include<vector>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<string>
#include<math.h>
#define MAXNUM 5050
using namespace std;
int dp[2][MAXNUM], N;
char str1[MAXNUM], str2[MAXNUM];
int main()
{
    //freopen("1.txt", "r", stdin);
    int i, j, k, t, tmp1, tmp2, cases, len;
    while (scanf("%d", &N) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        memset(str1, 0, sizeof(str1));
        memset(str2, 0, sizeof(str2));
        scanf("%s", str1 + 1);
        len = N;
        for (i = 1; i <= len; i++)
            str2[i] = str1[len + 1 - i];
        for (i = 1; i <= len; i++)
        {
            dp[1][0] = 0;
            for (j = 1; j <= len; j++)
            {
                if (str1[i] == str2[j])
                    dp[1][j] = dp[0][j - 1] + 1;
                else
                {
                    tmp1 = max(dp[0][j], dp[1][j - 1]);
                    dp[1][j] = max(tmp1, dp[0][j - 1]);
                }

            }
            for (j = 0; j <= len; j++)
                dp[0][j] = dp[1][j];
        }
        printf("%d\n", N - dp[1][len]);
    }
    return 0;
}

动态规划—->最优二分检索树
http://blog.csdn.net/ncepuzhuang/article/details/8924369
代码：
http://blog.csdn.net/sunkun2013/article/details/49908585

金星上的小沼泽
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划专题——背包问题
⚡
02-13 4万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
常见动态规划问题总结
mc695192383的博客
04-12 1万+
最近毕业面临找工作的问题，在刷各大厂笔试题的时候发现大厂特别爱考一类问题，就是动态规划问题。于是决定将我见到的各类常见的动态规划问题做个总结，方便后期复习。 动态规划即Dynamic Programming，简称DP，初接触动态规划问题会觉得这类问题很抽象，晦涩难懂，不同的问题的求解思路也是千差万别，但是从本质上来看动态规划问题，最核心的思想就是将一个大的问题拆分成一个一个的子问题，通过定义问
动态规划算法总结
sjk12332134的博客
10-27 1175
动态规划的基本思想 动态规划算法的基本思想是将代求解的的问题分为若干子问题，先求解子问题，再利用子问题的解得到原问题的解，这就要求问题整体的解一定也是局部的最优解。若用分治法求解时，有些子问题被重复计算了多次，如果能够保存子问题的答案，在求规模更大的问题的解的时候可以再利用以求得的答案，就可以避免大量重复计算。动态规划的本质思想是利用子问题求解原问题。这样就衍生出了两种解决问题的方法，一种是自顶向下递归式解决问题，这种方法代码书写简单，往往写出状态转移方程问题就能解决。但缺点...
背包问题大全（动态规划）
热门推荐
weixin_45746505的博客
05-02 6万+
背包问题是动态规划非常重要的一类问题，它有很多变种，但题目万变不离其宗。我们需要抓住关键的解题思路。
动态规划问题总结
zjkC050818的博客
07-06 4073
本文提纲参考自视频：https://www.bilibili.com/video/av9379437/#page=29 在介绍动态规划是什么之前，先来看一道题目 求解该题，有四种方法 在面试题中出现类似的题目，优化轨迹高度一致。 方法一：暴力搜索方法
最全动态规划总结
每日进步一点点
03-25 2万+
目录 一、动态规划初探 1、递推 2、记忆化搜索 3、状态和状态转移 4、最优化原理和最优子结构 5、决策和无后效性 二、动态规划的经典模型 1、线性模型 2、区间模型 3、背包模型 4、状态压缩模型 5、树状模型 三、动......
数字三角形（很经典的动态规划问题）
dont worry about it的博客
01-28 3万+
给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。
动态规划——背包问题
Ten_years_star的博客
08-17 2638
对于背包问题，今天我们先讲解，01背包，完全背包，和多重背包。
动态规划-背包问题详解
2203_75327677的博客
01-19 1451
基于动态规划，对背包问题的四种情况进行详解
动态规划常见问题
m0_63685436的博客
08-13 544
算法
C++之动态规划问题汇总
03-05
### C++ 动态规划问题汇总 #### 一、引言 动态规划（Dynamic Programming，简称 DP）是一种解决多阶段决策过程最优化问题的方法。它适用于具有重叠子问题和最优子结构特性的问题。本篇文章主要针对 LeetCode 中一些...
01背包问题动态规划z
11-16
动态规划解决问题的关键在于状态转移方程，01背包问题的状态转移方程可以总结为： ```markdown dp[i][w] = max(dp[i-1][w], dp[i-1][w-wi]+vi) if w >= wi dp[i-1][w] otherwise ``` 这里的max操作确保了我们始终...
动态规划-背包问题1
08-03
总结来说，0-1背包问题是一个典型的动态规划问题，其核心在于利用最优子结构和重叠子问题的特性，通过递归公式构建并填充一个二维数组，以找到背包容量限制下的最大价值解决方案。在实现过程中，通过跳跃点优化可以...
01背包问题动态规划.docx
最新发布
03-29
### 01背包问题动态规划解析 #### 一、问题背景与定义 01背包问题是一种典型的组合优化问题，属于动态规划的经典应用场景之一。该问题的基本形式为：假设有一个背包，其最大承载重量为\( W \)，同时有一系列物品...
哈希（poj相关题目）
ziqi9216的博客
06-29 647
hash
poj bfs与dfs总结之2251 Dungeon Master
ziqi9216的博客
07-12 536
总结： 1、如果是求最短路径，树的直径（两次bfs），一般用bfs 2、如果只是左转或者右转（像上一篇博客一样的话）就用dfs 3、如果是翻转系列的（flip game，行列变换）一定是dfs超时的：
poj 字符串相关的水题
ziqi9216的博客
06-26 418
1035 Spell checker
poj 贪心相关之 Y2K Accounting Bug2586
ziqi9216的博客
06-22 377
poj 贪心相关之 Y2K Accounting Bug2586 int m
动态规划问题详解：经典实例与解题关键
"常见动态规划问题的总结，包括10个经典题目，涉及寻找三角形最小路径、最大子数组和、回文最小划分次数、最佳股票买卖时机、字符串交叉存取判断、矩阵最小和计算、字符串最小编辑距离、数字解码方式、不同子序列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值