区间DP小结(附经典例题)

置顶 已于 2022-07-05 20:30:48 修改
阅读量2.5w 收藏 221
点赞数 65
分类专栏： 动态规划 文章标签： 区间DP 平行四边形优化 动态规划 石子合并 括号匹配
于 2017-08-13 12:50:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/my_sunshine26/article/details/77141398
版权

写这篇文章的目的主要是想总结下区间DP的经典题目，同时给自己复习巩固这方面知识点。

区间DP

一、定义

​ 区间DP是线性动态规划的扩展，适用场景为每段区间的最优解可以通过更小区间的最优解得到。所以我们一般的解题思路都是先在小区间得到最优解，然后总结出递推公式，利用小区间的最优解求大区间的最优解。

二、实现伪代码

//mst(dp,0) 初始化dp数组
for(int i=1;i<=n;i++)
{
    dp[i][i]=初始值
}
for(int len=2;len<=n;len++)  //枚举区间长度
for(int i=1;i<=n;i++)        //枚举起点
{
    int j=i+len-1;           //区间终点
    if(j>n) break;           //越界结束
    for(int k=i;k<j;k++)     //枚举分割点，构造状态转移方程
    {
        dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j]+w[i][j]);
    }
}

三、经典例题

1. 石子合并问题
1.1 石子合并(一)
石子合并(一)
Time Limit: 1000 MS Memory Limit: 65535 K

Problem Description

有N堆石子排成一排，每堆石子有一定的数量。现要将N堆石子并成为一堆。合并的过程只能每次将相邻的两堆石子堆成一堆，每次合并花费的代价为这两堆石子的和，经过N-1次合并后成为一堆。求出总的代价最小值。

Input
​有多组测试数据，输入到文件结束。
每组测试数据第一行有一个整数n，表示有n堆石子。
接下来的一行有n(0<n<200)个数，分别表示这n堆石子的数目，用空格隔开
Output

输出总代价的最小值，占单独的一行

Examples

Input

3

1 2 3

7

13 7 8 16 21 4 18

Output

9

239

【题目链接】link

【思路】

我们dp[i][j]来表示合并第i堆到第j堆石子的最小代价。

那么状态转移方程为

dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+w[i][j]);

其中w[i][j]表示把(i,j)和(k+1,j)这两部分合并起来的代价，即从第i堆到第j堆石子个数的和，为了方便查询并提高效率，我们可以利用前缀和预处理，用sum[i]表示从第1堆到第i堆的石子个数和，那么w[i][j]=sum[j]-sum[i-1]。

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 205;
const ll mod = 1e9+7;
const ll INF = 1e18;
const double eps = 1e-9;
 
int n,x;
int sum[maxn];
int dp[maxn][maxn];
 
int main()
{
    while(~scanf("%d",&n))
    {
        sum[0]=0;
        mst(dp,0x3f);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&x);
            sum[i]=sum[i-1]+x;
            dp[i][i]=0;
        }
        for(int len=2;len<=n;len++)
        for(int i=1;i<=n;i++)
        {
            int j=i+len-1;
            if(j>n) continue;
            for(int k=i;k<j;k++)
            {
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]);
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}

【拓展】平行四边形优化

上面的代码运行时间在240ms左右，通过这题完全没问题，但我们还可以考虑优化。

由于状态转移时是三重循环的，我们想能否把其中一层优化呢？尤其是枚举分割点的那个，显然我们用了大量的时间去寻找这个最优分割点，所以我们考虑把这个点找到后保存下来

用s[i][j]表示区间[i,j]中的最优分割点，那么第三重循环可以从[i,j-1)优化到【s[i][j-1],s[i+1][j]】。(这个时候小区间s[i][j-1]和s[i+1][j]的值已经求出来了，然后通过这个循环又可以得到s[i][j]的值)。

关于平行四边形优化的证明可以参考这篇博客: link

// 32ms
#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 205;
const ll mod = 1e9+7;
const ll INF = 1e18;
const double eps = 1e-9;
 
int n,x;
int sum[maxn];
int dp[maxn][maxn];
int s[maxn][maxn];
 
int main()
{
    while(~scanf("%d",&n))
    {
        sum[0]=0;
        mst(dp,0x3f);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&x);
            sum[i]=sum[i-1]+x;
            dp[i][i]=0;
            s[i][i]=i;
        }
        for(int len=2;len<=n;len++)
        for(int i=1;i<=n;i++)
        {
            int j=i+len-1;
            if(j>n) continue;
            for(int k=s[i][j-1];k<=s[i+1][j];k++)
            {
                if(dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1]<dp[i][j])
                {
                    dp[i][j]=dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1];
                    s[i][j]=k;
                }
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}
1.2 Monkey Party
Monkey Party
Time Limit: 2000 MS Memory Limit: 65535 K
Problem Description

Far away from our world, there is a banana forest. And many lovely monkeys livethere. One day, SDH(Song Da Hou), who is the king of banana forest, decides tohold a big party to celebrate Crazy Bananas Day. But the little monkeys don’tknow each other, so as the king, SDH must do something.
Now there are n monkeys sitting in a circle, and each monkey has a makingfriends time. Also, each monkey has two neighbor. SDH wants to introduce themto each other, and the rules are:
1.every time, he can only introduce one monkey and one of this monkey’sneighbor.
2.if he introduce A and B, then every monkey A already knows will know everymonkey B already knows, and the total time for this introducing is the sum ofthe making friends time of all the monkeys A and B already knows;
3.each little monkey knows himself;
In order to begin the party and eat bananas as soon as possible, SDH want toknow the mininal time he needs on introducing.

Input

There is several test cases. In each case, the first line is n(1 ≤ n ≤ 1000), whichis the number of monkeys. The next line contains n positive integers(less than1000), means the making friends time(in order, the first one and the last oneare neighbors). The input is end of file.

Output

For each case, you should print a line giving the mininal time SDH needs on introducing.

Examples

Input

8

5 2 4 7 6 1 3 9

Output

105

【题目链接】link

【题意】

问题转化后其实就是环形石子合并，即现在有围成一圈的若干堆石子，其他条件跟前面那题相同，问合并所需最小代价——上一题的升级版

【思路】

我们需要做的是尽量向简单的问题转化，可以把前n-1堆石子一个个移到第n个后面，那样环就变成了线，即现在有2*n-1堆石子需要合并，我们只要求下面的式子即可。求法与上面那题完全一样。

min(dp[s][s+n-1])，s ∈ \in ∈[1,n]

#include <cstdio>
#include <string>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 1005*2;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
 
int a[maxn];
int sum[maxn];
int dp[maxn][maxn];
int s[maxn][maxn];
 
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        sum[0]=0;
        mst(dp,0x3f);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            sum[i]=sum[i-1]+a[i];
            s[i][i]=i;
            dp[i][i]=0;
        }
        for(int i=1;i<n;i++)
        {
            sum[i+n]=sum[i+n-1]+a[i];
            s[i+n][i+n]=i+n;
            dp[i+n][i+n]=0;
        }
        for(int len=2;len<=n;len++)
        for(int i=1;i<=2*n-1;i++)
        {
            int j=i+len-1;
            if(j>2*n-1) break;
            for(int k=s[i][j-1];k<=s[i+1][j];k++)
            {
                if(dp[i][j]>dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1])
                {
                    dp[i][j]=dp[i][k]+dp[k+1][j]+sum[j]-sum[i-1];
                    s[i][j]=k;
                }
            }
        }
        int ans=INF;
        for(int i=1;i<=n;i++)
        {
            ans=min(ans,dp[i][i+n-1]);
        }
        printf("%d\n",ans);
    }
    return 0;
}
2. 括号匹配问题
2.1 Brackets
Brackets
Time Limit: 1000 MS Memory Limit: 65536 K
Problem Description We give the following inductive definition of a “regular brackets” sequence: the empty sequence is a regular brackets sequence, if s is a regular brackets sequence, then (s) and [s] are regular brackets sequences, and if a andb are regular brackets sequences, thenab is a regular brackets sequence. no other sequence is a regular brackets sequence For instance,all of the following character sequences are regular brackets sequences:

(), [], (()), ()[], ()[()]

while thefollowing character sequences are not:

(, ], )(, ([)], ([(]

Given a brackets sequence of characters a1a2 … an,your goal is to find the length of the longest regular brackets sequence that is a subsequence ofs. That is, you wish to find the largestmsuch that for indicesi1,i2, …,imwhere 1 ≤i1 <i2 < … <im≤n,ai1ai2 … aim is a regular bracketssequence.

Given the initial sequence ([([]])], the longest regularbrackets subsequence is[([])].

Input

The input test file will contain multiple test cases. Each input test case consists of asingle line containing only the characters(,),[, and]; each input test will have length between 1 and 100, inclusive. The end-of-file is marked by a line containing the word “end” and should not be processed.

Output

For each input case, the program should print the length of the longest possible regular brackets subsequence on a single line.

Examples

Input

((()))

()()()

([]])

)[)(

([][][)

end

Output

6

6

4

0

6

【题目链接】link

【题意】

给出一个的只有’(‘,’)‘,’[‘,’]'四种括号组成的字符串，求最多有多少个括号满足题目里所描述的完全匹配。

【思路】

用dp[i][j]表示区间[i,j]里最大完全匹配数。只要得到了dp[i][j]，那么就可以根据比较s[i-1]与s[j+1]是否匹配得到dp[i-1][j+1]

dp[i-1][j+1]=dp[i][j]+(s[i-1]与[j+1]匹配 ? 2 : 0)

然后利用状态转移方程更新一下区间最优解即可。

dp[i][j]=max(dp[i][j],dp[i][k]+dp[k+1][j])

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 105;
const ll mod = 1e9+7;
const ll INF = 1e18;
const double eps = 1e-9;
 
char s[maxn];
int dp[maxn][maxn];
 
int main()
{
    while(~scanf("%s",s+1)&&s[1]!='e')
    {
        int n=strlen(s+1);
        mst(dp,0);
        for(int len=2;len<=n;len++)
        for(int i=1;i<=n;i++)
        {
            int j=i+len-1;
            if(j>n) break;
            if(s[i]=='('&&s[j]==')'||s[i]=='['&&s[j]==']')
            {
                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][j]);
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}
2.2 括号匹配(2)
括号匹配(2)
Time Limit: 1000 MS Memory Limit: 65536 K
Problem Description

给你一个字符串，里面只包含"(“,”)“,”[“,”]"四种符号，请问你需要至少添加多少个括号才能使这些括号匹配起来。
如：
[]是匹配的
([])[]是匹配的
((]是不匹配的
([)]是不匹配的

Input
第一行输入一个正整数N，表示测试数据组数(N<=10)
每组测试数据都只有一行，是一个字符串S，S中只包含以上所说的四种字符，S的长度不超过100

Output

对于每组测试数据都输出一个正整数，表示最少需要添加的括号的数量。每组测试输出占一行

Examples

Input

4

[]

([])[]

((]

([)]

Output

0

0

3

2

【题目链接】link

【题意】

上一题求的是满足完美匹配的最大括号数量，而这题问的是使所有括号完美匹配需要添加的最小括号数量

【思路】

显然，要使添加的括号尽量少，我们需要使原来的括号序列尽可能多得匹配，即先求最大匹配数量(跟上题一样)，那么还剩下一些没有匹配的括号，我们就需要依次加上一个括号使它们得到匹配。综上所述，所求=原序列括号数量-最大匹配括号数量。(因此此题的代码与上题几乎一致)。

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 105;
const ll mod = 1e9+7;
const ll INF = 1e18;
const double eps = 1e-9;
 
char s[maxn];
int dp[maxn][maxn];
 
int main()
{
    rush()
    {
        scanf("%s",s+1);
        int n=strlen(s+1);
        mst(dp,0);
        for(int len=2;len<=n;len++)
        for(int i=1;i<=n;i++)
        {
            int j=i+len-1;
            if(j>n) break;
            if(s[i]=='('&&s[j]==')'||s[i]=='['&&s[j]==']')
            {
                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][j]);
            }
        }
        printf("%d\n",n-dp[1][n]);
    }
    return 0;
}
3. 整数划分问题
整数划分(四)
Time Limit: 1000 MS Memory Limit: 65536 K
Problem Description

暑假来了，hrdv又要留学校在参加ACM集训了，集训的生活非常Happy（ps：你懂得），可是他最近遇到了一个难题，让他百思不得其解，他非常郁闷。。亲爱的你能帮帮他吗？

问题是我们经常见到的整数划分，给出两个整数 n , m ,要求在 n 中加入m - 1 个乘号，将n分成m段，求出这m段的最大乘积

Input
第一行是一个整数T，表示有T组测试数据
接下来T行，每行有两个正整数 n，m ( 1<= n < 10^19, 0 < m <= n的位数)
Output

输出每组测试样例结果为一个整数占一行

Examples

Input

2

111 2

1111 2

Output

11

121

【题目链接】link

【题意】

给出一个数n,要求在n的数位间插入(m-1)个乘号，将n分成了m段，求这m段的最大乘积。

【思路】

用dp[i][j]表示从第一位到第i位共插入j个乘号后乘积的最大值。根据区间DP的思想我们可以从插入较少乘号的结果算出插入较多乘号的结果，在放第j个乘号的时候枚举放的位置

状态转移方程为

dp[i][j]=max(dp[i][j],dp[k][j-1]*num[k+1][i])

其中num[i][j]表示从s[i]到s[j]这段连续区间代表的数值，可以提前进行预处理得到

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 25;
const ll mod = 1e9+7;
const ll INF = 1e18;
const double eps = 1e-9;
 
int m;
char s[maxn];
ll dp[maxn][maxn];
ll num[maxn][maxn];
 
int main()
{
    rush()
    {
        scanf("%s%d",s+1,&m);
        mst(dp,0);
        int len=strlen(s+1);
        for(int i=1;i<=len;i++)
        {
            num[i][i]=s[i]-'0';
            for(int j=i+1;j<=len;j++)
            {
                num[i][j]=num[i][j-1]*10+s[j]-'0';
            }
        }
        for(int i=1;i<=len;i++)
        {
            dp[i][0]=num[1][i];
        }
        for(int j=1;j<m;j++)
        for(int i=j+1;i<=len;i++)
        for(int k=j;k<i;k++)
        {
            dp[i][j]=max(dp[i][j],dp[k][j-1]*num[k+1][i]);
        }
        printf("%lld\n",dp[len][m-1]);
    }
    return 0;
}
4. 凸多边形三角划分问题
三角划分
Time Limit: 1000 MS Memory Limit: 65536 K
Problem Description

给定一个具有N(N<=50)个顶点(从1到N编号)的凸多边形，每个顶点的权值已知。问如何把这个凸多边形划分成N-2个互不相交的三角形，使得这些三角形顶点的权值的乘积之和最小。

Input

第一行为顶点数N，第二行为N个顶点（从1到N）的权值
Output

乘积之和的最小值。题目保证结果在int范围内。

Examples

Input

5

1 6 4 2 1

5

121 122 123 245 231

Output

34

12214884

【思路】

用dp[i][j]表示从顶点i到顶点j的凸多边形三角剖分后所得到的最小乘积。

那么可以写出状态转移方程，并通过枚举分割点来转移

dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[k]*a[j]);

#include <cstdio>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 55;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
 
int a[maxn];
int dp[maxn][maxn];
 
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        mst(dp,0);
        for(int len=3;len<=n;len++)
        for(int i=1;i<=n;i++)
        {
            int j=i+len-1;
            if(j>n) break;
            dp[i][j]=INF;
            for(int k=i+1;k<j;k++)
            {
                dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[k]*a[j]);
            }
        }
        printf("%d\n",dp[1][n]);
    }
    return 0;
}

四、拓展例题

题目一
Cake slicing
Time Limit: 1000 MS Memory Limit: 32768 K
Problem Description

A rectangular cake with a grid of m*n unit squares on its top needs to be slicedinto pieces. Several cherries are scattered on the top of the cake with at mostone cherry on a unit square. The slicing should follow the rules below:

  1. each piece is rectangular or square;
  2. each cutting edge is straight and along a grid line;
  3. each piece has only one cherry on it;
  4. each cut must split the cake you currently cut two separate parts

For example, assume that the cake has a grid of 3*4 unit squares on its top,and there are three cherries on the top, as shown in the figure below.
在这里插入图片描述
One allowable slicing is as follows.
在这里插入图片描述

For this way of slicing , the total length of the cutting edges is 2+4=6.
Another way of slicing is
在这里插入图片描述

In this case, the total length of the cutting edges is 3+2=5.

Give the shape of the cake and the scatter of the cherries , you are supposedto find
out the least total length of the cutting edges.

Input

The input file contains multiple test cases. For each test case:
The first line contains three integers , n, m and k (1≤n, m≤20), where n*m isthe size of the unit square with a cherry on it . The two integers showrespectively the row number and the column number of the unit square in thegrid .
All integers in each line should be separated by blanks.
Output

Output an integer indicating the least total length of the cutting edges.

Examples

Input

3 4 3

1 2

2 3

3 2

Output

Case 1: 5

【题目链接】link

【题意】

有一个n*m大小的蛋糕，上面有k个樱桃，现在我们需要把这个蛋糕切成k份，使每份蛋糕上有一个樱桃，问最小切割长度和(切割一刀必须切到底)

【思路】

用dp[i][j][k][l]表示以(i,j)为左上角，(k,l)为右下角的矩形切成每份一个樱桃的最小切割长度。然后就利用区间DP，枚举切割点，从小区间转移到大区间。由于这道题不同区间樱桃个数不同，故用递归的写法会方便些。

#include <cstdio>
#include <cmath>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 25;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
 
int n,m,k;
int dp[maxn][maxn][maxn][maxn];
bool flag[maxn][maxn];     //记录某个点是否有樱桃
 
int fun(int a,int b,int c,int d)
{
    if(dp[a][b][c][d]!=-1)  //已经计算过
    {
        return dp[a][b][c][d];
    }
    int cnt=0;
    for(int i=a;i<=c;i++)
    for(int j=b;j<=d;j++)
    {
        if(flag[i][j])
            cnt++;
    }
    if(cnt<=1)            //区域内樱桃个数小于2，那么不用切割
    {
        return dp[a][b][c][d]=0;
    }
    int Min=INF;
    for(int i=a;i<c;i++)  //横着切
    {
        Min=min(Min,fun(a,b,i,d)+fun(i+1,b,c,d)+(d-b+1));
    }
    for(int i=b;i<d;i++)  //竖着切
    {
        Min=min(Min,fun(a,b,c,i)+fun(a,i+1,c,d)+(c-a+1));
    }
    return dp[a][b][c][d]=Min;
}
 
int main()
{
    int cas=1;
    int x,y;
    while(~scanf("%d%d%d",&n,&m,&k))
    {
        mst(dp,-1);
        mst(flag,0);
        for(int i=0;i<k;i++)
        {
            scanf("%d%d",&x,&y);
            flag[x][y]=1;
        }
        int ans=fun(1,1,n,m);
        printf("Case %d: %d\n",cas++,ans);
    }
    return 0;
}
题目二
String painter
Time Limit: 2000 MS Memory Limit: 32768 K
Problem Description

There are two strings A and B with equal length. Both strings are made up of lowercase letters. Now you have a powerful string painter. With the help of thepainter, you can change a segment of characters of a string to any othercharacter you want. That is, after using the painter, the segment is made up of only one kind of character. Now your task is to change A to B using string painter. What’s the minimum number of operations?

Input
Input contains multiple cases. Each case consists of two lines:
The first line contains string A.
The second line contains string B.
The length of both strings will not be greater than 100.
Output

A single line contains one integer representing the answer.

Examples

Input

zzzzzfzzzzz

abcdefedcba

abababababab

cdcdcdcdcdcd

Output

6

7

【题目链接】link

【题意】

给出字符串A和B，每一次我们可以使用一种颜色（用字母代替）刷任意一个连续子序列，问将字符串A变成字符串B最少需要刷多少次。

【思路】

分析了很久，发现直接去考虑将A串刷成B串非常困难。于是我们考虑间接转化。

用dp[i][j]表示把将一个空白串[i,j]刷成B字符串对应位置的最小次数。

用ans[i]表示把A串的区间[1,i]刷成B串需要的最小次数。

然后状态转移一下就OK啦。

#include <cstdio>
#include <cmath>
#include <queue>
#include <cstring>
#include <algorithm>
using namespace std;
#define mst(a,b) memset((a),(b),sizeof(a))
#define rush() int T;scanf("%d",&T);while(T--)
 
typedef long long ll;
const int maxn = 105;
const ll mod = 1e9+7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-9;
 
char s1[maxn],s2[maxn];
int dp[maxn][maxn];
int ans[maxn];
 
int main()
{
    while(~scanf("%s%s",s1+1,s2+1))
    {
        int n=strlen(s1+1);
        mst(dp,0);
        for(int i=1;i<=n;i++)
        for(int j=i;j<=n;j++)
        {
            dp[i][j]=j-i+1;
        }
        for(int j=1;j<=n;j++)
        for(int i=j;i>=1;i--)
        {
            dp[i][j]=dp[i+1][j]+1;
            for(int k=i+1;k<=j;k++)
            {
                if(s2[i]==s2[k])        //这样的话s2[i]可以跟左半区间一起刷到
                {
                    dp[i][j]=min(dp[i][j],dp[i+1][k]+dp[k+1][j]);
                }
            }
        }
        for(int i=1;i<=n;i++)
        {
            ans[i]=dp[1][i];
            if(s1[i]==s2[i])
            {
                ans[i]=min(ans[i],ans[i-1]);
            }
            else 
            for(int j=1;j<i;j++)
            {
                ans[i]=min(ans[i],ans[j]+dp[j+1][i]);  //已得出的最优解+剩下的按空白串去刷
            }
        }
        printf("%d\n",ans[n]);
    }
    return 0;
}

2022/07/05：排版优化

Dust_Heart
关注
专栏目录
区间dp（动态规划）
小天狼星_布莱克 的博客
07-06 4386
动态规划（dp）是一种通过将问题分解为子问题，并利用已解决的子问题的解来求解原问题的方法。适用于具有重叠子问题和最优子结构性质的优化问题。通过定义状态和状态转移方程，动态规划可以在避免重复计算的同时找到问题的最优解，是一种高效的求解方法，常用于解决各种问题，如最短路径、背包问题、序列比对等。区间dp是一种dp的应用，用于解决涉及区间的问题。它将问题划分为若干个子区间，并通过定义状态和状态转移方程来求解每个子区间的最优解，最终得到整个区间的最优解。
区间dp-基本知识以及例题
09-02
区间dp-基本知识以及例题
区间dp（含模板及例题）
Easenyang的博客
05-16 6617
概述： 区间dp：就是对于区间的一种动态规划，对于某个区间，它的合并方式可能有很多种，我们需要去枚举所有的方式，通常是去枚举区间的分割点，找到最优的方式(一般是找最少消耗)。 例如：对于区间【i，j】，它的合并方式有很多种，可以是【i，i+1】和【i+2，j】也可以是【i，k】和【k+1，j】（其中i<k<j）…… 在合并区间时，一般会有消耗（根据题意去计算），状态转移方程就可以表示成： dp[i][j] = min(dp[i][j], dp[i,k] + dp[k+1][j]
动态规划入门（九） 区间DP
热门推荐
Hello World!
05-03 5万+
顾名思义，区间dp就是在区间上进行动态规划，求解一段区间上的最优解；该问题的求解思路主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。
区间dp 总结&详解
seanli1008的博客
10-02 988
区间 dp
动态规划——区间dp
qq_57150526的博客
12-29 1353
区间dp就是在区间上进行动态规划，求解一段区间上的最优解。主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。区间dp主要运用了分治的思想，将大问题差分成一个个小问题求解，最终将得到全局最优解。
石子合并 区间dp
WananRd
06-03 1084
前缀和、区间dp
动态规划：区间DP 详解（三道例题c++实现）
ylh的博客
02-07 1112
区间DP 动态规划： 三道例题！！ 关路灯，能量项链，合唱队
mythsman#blog-source#区间dp专题小结1
07-25
区间DP是一类在区间上进行动态规划的最优问题，一般是根据问题设出一个表示状态的dp，可以是二维的也可以是三维的，一般情况下为二维。然后将问题划分成两个子问题，也
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
CodeForces – 1312E Array Shrinking(区间dp)
01-03
题目分析：最优性问题，且是对区间操作的，而且数据范围满足 n^3 的时间复杂度，综上可以考虑区间dp，因为题目已经明确了需要求什么，所以我们不妨设 dp[ i ][ j ] 为区间 [ i , j ] 合并后的最短数列的长度，因为...
3区间DP1
08-08
在这个题目中，我们通过C++语言实现了一个基础的3区间DP求解器。 首先，我们需要理解动态规划的核心思想：将复杂问题分解为更小的子问题，并存储子问题的解，避免重复计算。3区间DP在此基础上增加了对3个连续子数组...
区间DP详解
m0_52058484的博客
04-05 1095
区间DP思路解析
算法套路十八——区间 DP
Pistachiout的学习博客
05-24 1388
区间DP:需要确定给定区间内所有可能状态的问题，并从较小区间向较大区间进行转移。
区间dp学习笔记
2302_79085527的博客
03-21 1223
5.那么f[i][k]+f[k+1][j]+sum(i,k)+sum(k+1,j)就是先将[i,k]合并为一堆，再将[k+1,j]合并为一堆，最后将这两堆合并成[i,j]的最小花费。例如令f[i][j]为区间[l,r]的最大值，则f[i][j]=max{f[i][k]+f[k+1][j]+cost|l≤k<r}(这里是伪代码)令f[i][j]为区间[l,r]变成回文串的最小花费，如果s[l]=s[r]，即当前串两端字符相同，那么f[l][r]=f[l+1][r-1]]变为回文串，再增加或删除E。
区间dp及经典习题
cckqqq的博客
01-08 568
2024年的第一篇文章啊，也向大家送来一个迟来的新年祝福，接下来我将通过一些经典的习题来讲解一下区间dp区间dp就是以区间长度为阶段，由小的区间长度递推出大的区间长度的dp，口说无用，让我们见题说话吧。
动态规划： 四道例题入门区间DP （c++ ）
ylh的博客
02-06 553
区间DP 动态规划 石子合并 粉刷字符串 最小代价构造回文串 相亲的男孩
动态规划之区间dp(题集)
AIRBOYONE的博客
07-24 795
目录 1.被3整除的子序列 2.Eating Together 3.Basketball Exercise： 4.RGB Substring 5.小明打联盟 6.乘积最大 7.Make The Fence Great Again 1.被3整除的子序列 题目描述 给你一个长度为50的数字串,问你有多少个子序列构成的数字可以被3整除 答案对1e9+7取模 输入描述: 输入一个...
【算法与数据结构】——区间DP
气派飞鹰的博客
08-06 505
介绍 区间DP属于线性DP的一种，以区间长度作为DP的阶段，以区间的左右端点作为状态的维度。一个状态通常由被它包含且比它更小的区间状态转移而来。阶段（长度），状态（左右端点），决策三者按照由外岛内的顺序构成3层循环。 接下来介绍一个典型问题。 石子合并问题 有N堆石子排成一排，每堆石子有一定的数量。先要将2堆石子合并成一堆，每次合并花费的代价为这两堆石子的和，经过N-1次合并后称为一堆。求总的代价最小值。 问题分析： 1.求某个区间的最优解[1,n]; 2.大的区间由包含于它的小区间组成（转移而来）； 3.
如何高效地使用动态规划解决区间DP问题，并给出具体的编码实现示例？
最新发布
10-27
参考资源链接：[计算机考研机试满分攻略：速成技巧与实战](https://wenku.csdn.net/doc/45v6ytnvt8?utm_source=wenku_answer2doc_content) 动态规划是解决优化问题的一种常用方法，尤其是区间DP问题。区间DP是动态规划的一种特例，其核心思想是在解决问题时，将问题划分为若干区间进行分治处理。要掌握区间DP，首先需要理解状态的定义和状态转移方程。具体实现时，往往需要从较小的区间开始逐步扩展到较大的区间，通过区间合并的方式来逐步求解整个问题。 例如，在解决“最长公共子序列”问题时，可以定义状态dp[i][j]表示考虑字符串a的前i个字符和字符串b的前j个字符，所能得到的最长公共子序列的长度。状态转移方程可以表示为：dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1] + (a[i] == b[j] ? 1 : 0))。这样，通过两层循环遍历所有字符组合，就可以求得最终解。 在编码实现时，可以使用二维数组dp来存储状态，然后通过双层循环计算每个状态的值。为了优化空间复杂度，有时可以只使用一维数组，并通过反向更新的方式进行状态转移。在具体编码时，应确保循环的顺序和状态更新的正确性，避免在计算dp[i][j]时使用到还未计算的dp值。 推荐通过《计算机考研机试满分攻略：速成技巧与实战》一书中的相关章节来学习区间DP的更多应用和优化技巧。书中不仅提供了区间DP问题的详细解析，还包括了如何优化编码实现和提高解题效率的实战建议。通过阅读本书，你将能够掌握更多高效解决区间DP问题的方法，并在实际编程中灵活应用。 参考资源链接：[计算机考研机试满分攻略：速成技巧与实战](https://wenku.csdn.net/doc/45v6ytnvt8?utm_source=wenku_answer2doc_content)
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值