区间dp入门[POJ2955][HDU2476][POJ3186][POJ1651][HDU4632][HDU4283][HDU4570][POJ3280]

最新推荐文章于 2020-04-16 20:13:13 发布
最新推荐文章于 2020-04-16 20:13:13 发布
阅读量397 收藏
点赞数
分类专栏： ACM_DP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24833289/article/details/47683225
版权

区间dp问题，通常给出一个序列，用dp[ i ][ j ] 表示序列为ai,a(i + 1)...aj时的答案，而较长的序列的答案由较短的序列的答案递推得到，让人想到矩阵连乘顺序问题。

所以解题的时候会用到3个循环：

第一层枚举序列长度 jj

第二层枚举序列开头的位置 i

第三层枚举序列 [i, i + jj ] 中间点 k，其中第三层有时是不需要的


下面是一些区间dp入门题，大同小异，这里就不给出思路了，看下代码大概就明白了


题目：POJ 2955 http://poj.org/problem?id=2955

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
int dp[105][105];
char s[105];

int match(int l, int r)
{
    if(s[l] == '(' && s[r] == ')') return 1;
    if(s[l] == '[' && s[r] == ']') return 1;
    return 0;
}

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    while(scanf("%s", s) != EOF && s[0] != 'e')
    {
        int len = strlen(s);
        memset(dp, 0, sizeof(dp));
        for(int jj = 1; jj < len; jj++)
        {
            for(int i = 0; i + jj < len; i++)
            {
                int j = i + jj;
                if(match(i, j))
                {
                    dp[i][j] = max(dp[i][j], dp[i + 1][j - 1] + 2);
                }
                for(int k = i; k < j; k++)
                {
                    dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j]);
                }
                //printf("dp[%d][%d]=%d\n", i, j, dp[i][j]);
            }
        }
        printf("%d\n", dp[0][len - 1]);
    }

    return 0;
}



题目：HDU 2476  http://acm.hdu.edu.cn/showproblem.php?pid=2476

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
char A[105], B[105];
int dp[105][105], ans[105];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int l, r;
    while(scanf("%s%s", A, B) != EOF)
    {
        int len = strlen(A);
        memset(dp, 0, sizeof(dp));
        for(int jj = 0; jj < len; jj++)
        {
            for(int i = 0; i + jj < len; i++)
            {
                int j = i + jj;
                dp[i][j] = dp[i + 1][j] + 1;
                for(int k = i + 1; k <= j; k++)
                {
                    if(B[i] == B[k])
                    dp[i][j] = min(dp[i][j], dp[i + 1][k] + dp[k + 1][j]);
                }
                //printf("dp[%d][%d]=%d\n", i, j, dp[i][j]);
            }
        }
        for(int i = 0; i < len; i++)
            ans[i] = dp[0][i];
        for(int i = 0; i < len; i++)
        {
            if(B[i] == A[i])
            {
                if(i == 0)
                    ans[i] = 0;
                else
                    ans[i] = ans[i - 1];
            }
            else
            {
                for(int j = 0; j < i; j++)
                {
                    ans[i] = min(ans[i], ans[j] + dp[j + 1][i]);
                }
            }
        }
        printf("%d\n", ans[len - 1]);
    }

    return 0;
}

题目：POJ 3186  http://poj.org/problem?id=3186

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
int v[2005], sum[2005], dp[2005][2005], a[2005][2005];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n;
    while(scanf("%d", &n) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        memset(a, 0, sizeof(a));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &v[i]);
            dp[i][i] = v[i];
            a[i][i] = v[i];
            //printf("a[%d][%d]=%d\n", i, i, a[i][i]);
        }
        sum[0] = v[0];
        for(int i = 1; i < n; i++)
        {
            sum[i] = sum[i - 1] + v[i];
            a[0][i] = sum[i];
            //printf("a[0][%d]=%d\n", i, a[0][i]);
        }
        for(int i = 1; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                a[i][j] = sum[j] - sum[i - 1];
                //printf("a[%d][%d]=%d\n", i, j, a[i][j]);
            }
        }
        for(int jj = 1; jj < n; jj++)
        {
            for(int i = 0; i + jj < n; i++)
            {
                int j = i + jj;
                dp[i][j] = max(dp[i][j], dp[i + 1][j] + a[i + 1][j] + a[i][i]);
                dp[i][j] = max(dp[i][j], dp[i][j - 1] + a[i][j - 1] + a[j][j]);
                //printf("dp[%d][%d]=%d\n", i, j, dp[i][j]);
            }
        }
        printf("%d\n", dp[0][n -1]);
    }

    return 0;
}



题目：POJ 1651  http://poj.org/problem?id=1651

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
int dp[105][105];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, a[105];
    while(scanf("%d", &n) != EOF)
    {
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
        }
        for(int i = 0; i <= n; i++)
        {
            for(int j = 0; j <= n; j++)
                dp[i][j] = 100000100;
        }
        for(int i = 1; i < n - 1; i++)
        {
            dp[i - 1][i + 1] = a[i - 1] * a[i] * a[i + 1];
            //printf("dp[%d][%d]=%d\n", i - 1, i + 1, dp[i - 1][i + 1]);
        }
        for(int jj = 3; jj < n; jj++)
        {
            for(int i = 0; i + jj < n; i++)
            {
                int j = i + jj;
                for(int k = i + 2; k + 1< j; k++)
                {
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j]
                                       + a[i] * a[k] * a[j]);
                }
                dp[i][j] = min(dp[i][j], dp[i][j - 1] + a[i] * a[j - 1] * a[j]);
                dp[i][j] = min(dp[i][j], dp[i + 1][j] + a[i] * a[i + 1] * a[j]);
                //printf("dp[%d][%d]=%d\n", i, j, dp[i][j]);
            }
        }
        printf("%d\n", dp[0][n - 1]);
    }

    return 0;
}

题目：HDU 4632  http://acm.hdu.edu.cn/showproblem.php?pid=4632

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 10007
#define INF 0x7fffffff
using namespace std;
char s[1005];
int dp[1005][1005];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int t;
    scanf("%d", &t);
    for(int cas = 1; cas <= t; cas++)
    {
        scanf("%s", s);
        int len = strlen(s);
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < len; i++)
        {
            dp[i][i] = 1;
        }
        for(int jj = 1; jj < len; jj++)
        {
            for(int i = 0; i + jj < len; i++)
            {
                int j = i + jj;
                dp[i][j] = max(dp[i][j], dp[i][j - 1] + dp[i + 1][j]
                                   - dp[i + 1][j - 1] + MOD);
                if(s[i] == s[j])
                {
                    dp[i][j] += dp[i + 1][j - 1] + 1 + MOD;
                }
                dp[i][j] %= MOD;
            }
        }
        printf("Case %d: %d\n", cas, dp[0][len - 1]);
    }

    return 0;
}

题目：HDU 4283  http://acm.hdu.edu.cn/showproblem.php?pid=4283

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff
using namespace std;
int d[105], dp[105][105], a[105][105], sum[105];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int t, n;
    scanf("%d", &t);
    for(int cas = 1; cas <= t; cas++)
    {
        scanf(" %d", &n);
        memset(dp, 0, sizeof(dp));
        memset(a, 0, sizeof(a));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &d[i]);
            dp[i][i] = 0;
            a[i][i] = d[i];
        }
        sum[0] = d[0];
        for(int i = 1; i < n; i++)
        {
            sum[i] = a[0][i] = sum[i - 1] + d[i];
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                dp[i][j] = 1000010;
                if(i > 0)a[i][j] = sum[j] - sum[i - 1];
                //printf("a[%d][%d]=%d\n", i, j, a[i][j]);
            }
        }
        for(int j = 1; j < n; j++)
        {
            for(int i = 0; i + j < n; i++)
            {
                //dp[i][i + j] = min(dp[i][i + j], dp[i + 1][i + j] + a[i + 1][i + j]);
                for(int k = 0; k <= j; k++)
                {
                    dp[i][i + j] = min(dp[i][i + j], dp[i + 1][i + k] + k * a[i][i]
                                       + dp[i + k + 1][i + j] + (k + 1) * a[i + k + 1][i + j]);
                }
                //dp[i][i + j] = min(dp[i][i + j], dp[i + 1][i + j] + a[i][i] * j);
                //printf("dp[%d][%d]=%d\n", i, i + j, dp[i][i + j]);
            }
        }
        printf("Case #%d: %d\n", cas, dp[0][n - 1]);
    }

    return 0;
}


题目：HDU 4570  http://acm.hdu.edu.cn/showproblem.php?pid=4570

代码：

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 1 << 30 - 1
typedef long long ll;
using namespace std;
ll dp[70][70], a[70];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int t, n;
    //printf("INF=%I64d\n", INF);
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d", &n);
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i < n; i++)
        {
            scanf("%I64d", &a[i]);
        }
        for(int i = 0; i < n; i++)
        {
            dp[i][i] = a[i] * 2;
            for(int j = i + 1; j < n; j++)
            {
                dp[i][j] = INF;
            }
        }
        for(int jj = 1; jj < n; jj++)
        {
            for(int i = 0; i + jj < n; i++)
            {
                int j = i + jj;
                for(int k = i; k < j; k++)
                {
                    dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
                    if(jj <= 19)
                    {
                        ll cur = a[i];
                        for(int cnt = 1; cnt <= (jj + 1); cnt++)
                            cur *= 2;
                        dp[i][j] = min(dp[i][j], cur);
                    }
                }
                //printf("dp[%d][%d]=%d\n", i, j, dp[i][j]);
            }
        }
        printf("%I64d\n", dp[0][n - 1]);
    }

    return 0;
}

题目：POJ 3280  http://poj.org/problem?id=3280
代码： 

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#define MOD 1000000007
#define INF 0x7fffffff - 20010
using namespace std;
char s[2005];
int add[30], del[30], dp[2005][2005];

int main()
{
    #ifdef LOCAL
    freopen("dpdata.txt", "r", stdin);
    #endif

    int n, m;
    char c;
    while(scanf("%d %d ", &n, &m) != EOF)
    {
        memset(add, 0, sizeof(add));
        memset(del, 0, sizeof(del));
        memset(dp, 0, sizeof(dp));
        for(int i = 0; i <= m; i++)
        {
            for(int j = i + 1; j <= m; j++)
            {
                dp[i][j] = INF;
            }
        }
        scanf("%s", s);
        for(int i = 0; i < n; i++)
        {
            scanf(" %c", &c);
            scanf("%d%d", &add[c - 'a'], &del[c - 'a']);
        }
        for(int jj = 1; jj < m; jj++)
        {
            for(int i = 0; i + jj < m; i++)
            {
                int j = i + jj;
                if(s[i] != s[j])
                {
                    dp[i][j] = min(dp[i][j], dp[i + 1][j] + add[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 + 1][j] + del[s[i] - 'a']);
                    dp[i][j] = min(dp[i][j], dp[i][j - 1] + del[s[j] - 'a']);
                }
                else
                {
                    dp[i][j] = min(dp[i][j], dp[i + 1][j - 1]);
                }
                //printf("dp[%d][%d] = %d\n", i, j, dp[i][j]);
            }
        }
        printf("%d\n", dp[0][m - 1]);
    }

    return 0;
}


cookiesMonster
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
poj2955(区间dp)
lixiaomu2的博客
05-02 233
题目 大意：给出一个字符串，求其中最长括号都已匹配好子串(只需知道长度即可) 比较简单的区间dp, 对于f[i][i+1],如果第i个字符与第i+1个匹配则f[i][i+1]=2否则等于0 其他的,f[i][j]=max(f[i][k]+f[k+1][j])(分两段考虑),(形式类似(S1)(S2)) 如果第i个字符与第j个字符匹配,则最优方案中两者可能在同一段, 此时f[i][j]=
POJ+HDU题库使用指南
qq_46476515的博客
09-03 2280
POJ解题指南
UVA1566 LA3830 POJ3480 HDU1907 John【博弈】
海岛Blog
04-16 351
John Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 3727 Accepted: 1863 Description Little John is playing very funny game with his younger brother. There is one big box filled with M&am...
POJ1458 HDU1159 ZOJ1733 UVALive2759 Common Subsequence【最长公共子序列+DP】
海岛Blog
11-30 468
Common Subsequence Time Limit: 1000MS Memory Limit: 10000K Total Submissions: 63742 Accepted: 26604 Description A subsequence of a given sequence is the given sequence with some elements (possible n...
UVALive2536 POJ1248 HDU1015 ZOJ1403 Safecracker【密码+暴力＋水题】
海岛Blog
07-27 1326
Safecracker Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 3277   Accepted: 1741 Description "The item is locked in a Klein safe behind a painting in the se
DP.rar_DP_hdu_动态规划_动态规划 C++
最新发布
09-20
描述中提到的“动态规划DP题解”和“POJ HDU部分动态规划DP题解”，说明这个压缩包包含了针对HDU和POJ（Problemset Online Judge）平台上一些动态规划题目的解答。POJ是一个著名的在线编程竞赛平台，其中包含了大量...
hdu oj poj 题目代码与详解
09-08
【题目代码与详解】是针对在线编程竞赛平台HDU（杭州电子科技大学在线评测系统）和POJ（普林斯顿大学在线判题系统）中的经典题目所编写的解决方案和解析的集合。这些平台是程序员和计算机科学学生提升算法技能、熟悉...
HDU&&POJ图论题集
04-24
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个...
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
POJ 2063 Investment （完全背包）
cookiesMonster
02-05 631
题意：我有很多钱，要用来买债券，已知每种债券的价格和每一期可获得的利润（注意债券的价格只能为1000的倍数），而且我可以每一期把原来的债券卖掉，然后用原来的钱加上利润选择新的购买方案。已知我要一开始有多少钱和我将购买多少期债券，求出我最后有多少钱。 思路：完全背包。一开始看到债券价格为1000的倍数，我就用了 for(int j = value[i]; j …… str += a
树形dp入门[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]
cookiesMonster
08-15 568
[POJ1655][HDU1520][HDU1561][HDU1011][POJ1155][ZOJ3626]树形dp中，我们可以很容易利用题目给出的数据构建出一棵树，然后我们会用dp[i]记录，选择以 i 为根的子树中的点能得到的最优答案。而dp[i]的值可以根据，i节点的子节点u1,u2...un对应的dp[u1],dp[u2]...dp[un]，递推得到。树形dp通常用搜索的形式实现，由于是树的结构，所以不包含重复的搜索，复杂度为O（n）。
经典动态规划问题 背包问题 [POJ3211][POJ2063][HDU1114][POJ1276][POJ1014][POJ1742][ZOJ3631]
cookiesMonster
08-14 515
[POJ3211][POJ2063][HDU1114][POJ1276][POJ1014][POJ1742][ZOJ3631] 最长上升自序列问题（LIS） 给出n个整数a1,a2...an组成序列，求最长的上升子序列（若i 时间复杂度为O(n^2)的做法： dp[i]表示以ai为末尾的最长上升子序列长度，则有 当a[j] 时间复杂度O(nlogn)的做法： dp[i]表示长度为i的上升子序列末尾元素的最小值，则对于每个元素ai，二分查找数组dp，找到第一个dp[]值不小于ai的位置，将其值变为ai 例题
状态压缩dp入门[HDU1074][HDU1065][POJ3254][POJ1185][HDU4359][POJ3311][POJ2411]
cookiesMonster
08-14 506
[HDU1074][HDU1065][POJ3254][POJ1185][HDU4359][POJ3311][POJ2411] 我理解的状态压缩dp问题是这样的： 给出你n个物品，你要在这n个物品中选出一些物品（或一个都不选），那么对于每个物品你都有两种选择（选或者不选），这样，一共有2^n种情况。而n 如：总共有5个物品，则最多有32种取物品的情况，13 对应5位的二进制数01101，就表示取物品2，3，5。对于每个5位的二进制数我们都用5次位运算判断它的各个位是1还是0。本来每个状态要用5个空间存，现在
单调队列优化dp [HDU2191][HDU3401][POJ1821]
cookiesMonster
10-05 448
用单调队列优化形如 dp[i][j] = max(dp[i - 1][k] + (j - k) * a[i]) 的状态转移 上式可化为dp[i][j] = max(dp[i - 1][k] - k * a[i]) + j * a[i]， 在不用单调队列优化前，对于dp[i][j] 和dp[i][j + 1]枚举 k 时发现，有重复的部分，而且都是取dp[i - 1][...k...]...的最
ZOJ 3626 Treasure Hunt I （树形dp）
cookiesMonster
08-16 417
题目：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3626 题意：有一个危险的村庄，这里有时会有怪兽出现，已知怪兽多久会出现一次，怪兽出现之后发现谁不在家，就会把谁杀掉。一个勇士要得到了一张藏宝图并要去找宝藏，他知道村庄之间的距离和每个村庄里有多少宝藏，问他不被怪兽杀掉的话，最多能拿到多少宝藏。给出的n个村庄和n-1条
codeforce #331D Wilbur and Trees （记忆化搜索DP）
cookiesMonster
11-24 417
题目：http://codeforces.com/contest/596/problem/D 题意：有n课树并排排列，没课树高h，砍树。每次，从剩余的树中选最左边的或最右边的（概率相等，0.5），砍掉一棵树，树倒向左边的概率为p，倒向右边的概率为1-p。如果树和相邻树的距离小于h，树倒时会把相邻的树撞倒。问，砍完所有树，树干覆盖的草地长度的期望值。 思路： dp[ l ][ r ] 表示看完
概率dp入门[HDU5001][POJ2151][POJ3071][HDU3853][POJ2096]
cookiesMonster
09-14 389
[HDU5001][POJ2151][POJ3071][HDU3853][POJ2096] 概率分为求概率和求期望两种： 求概率从起点开始求解，因为起点发生的概率通常可以确定，为1； 求期望从终点开始求解，因为通常记录从某个点到终点的期望，即先确定了终点到终点的期望。 例题 HDU 5001 概率 http://acm.hdu.edu.cn/showproblem.php?pid=5001 题意：有一个图，n个点，m条边，（起点随机）我在某个点随便找一条相邻边消耗1
HDU 1114 Piggy-Bank （完全背包）
cookiesMonster
02-04 383
题意：知道储钱罐里的硬币重量和各种面值硬币对应的重量，若能确定其中硬币的最小总价值，输出最小总价值，否则输出This is impossible. 思路：需要注意最小总价值时硬币重量是否与已知相等的判断。 #include int p[510], w[510]; int ans[10010]; int main() { #ifdef LOCAL freope
博弈问题解析：HDU Online Judge与Poj1067的石子游戏策略
这篇资源主要涉及的是博弈问题的解决方法，特别是关于HDU Online Judge上的几道题目，包括HDU 2516, POJ 1067, HDU 1527, HDU 2177以及HDU 2176。这些题目都是关于石子游戏的，玩家需要在一定的规则下决定如何取石子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值