区间dp

一.什么是区间dp?

顾名思义：区间dp就是在区间上进行动态规划，求解一段区间上的最优解。主要是通过合并小区间的 最优解进而得出整个大区间上最优解的dp算法。

二.核心思路

既然让我求解在一个区间上的最优解，那么我把这个区间分割成一个个小区间，求解每个小区间的最优解，再合并小区间得到大区间即可。所以在代码实现上，我可以枚举区间长度len为每次分割成的小区间长度（由短到长不断合并），内层枚举该长度下可以的起点，自然终点也就明了了。然后在这个起点终点之间枚举分割点，求解这段小区间在某个分割点下的最优解。
 

一般的形式

for(int len = 1;len<=n;len++){//枚举长度
        for(int j = 1;j+len<=n+1;j++){//枚举起点，ends<=n
            int ends = j+len - 1;
            for(int i = j;i<ends;i++){//枚举分割点，更新小区间最优解
                dp[j][ends] = min(dp[j][ends],dp[j][i]+dp[i+1][ends]+something);
            }
        }
    }

 

/*
51nod 1021
*/
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstdlib>
#include<cstring>
using namespace std;
const int inf=0x3f3f3f3f;
int a[110];
int dp[110][110];
int sum[110];//dp[i][j] i到j最小花费 
int main()
{
	int n;scanf("%d",&n);
	memset(dp,inf,sizeof(dp));
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
		sum[i]=sum[i-1]+a[i];
		dp[i][i]=0;
	}
	for(int len=1;len<=n;len++){
		for(int j=1;j+len<=n+1;j++){
			int end=j+len-1;
			for(int i=j;i<end;i++){
				dp[j][end]=min(dp[j][end],dp[j][i]+dp[i+1][end]+sum[end]-sum[j-1]);
			}
		}
	}
	printf("%d\n",dp[1][n]);
	return 0;
} 

 

51node 1022 石子归并 V2

思路：环状以后合并区间的情况就可以从后往前合并，最后合并完成可能是1~n,2~n~1,3~n~2.....这种n个石子合并的情况。所以我们可以破环成链，将前n-1各元素也放到n后面构成一个线性的环状序列，在对这个序列dp即可

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f
int stone[105];
int dpmin[205][205];//最小
int dpmax[205][205];//最大
int sum[205];
int main()
{
    int n;
    scanf("%d",&n);
    memset(sum,0,sizeof(sum));
    memset(dpmin,INF,sizeof(dpmin));
    memset(dpmax,-1,sizeof(dpmax));
    for(int  i =1;i<=n;i++){
        scanf("%d",&stone[i]);
        sum[i] = sum[i - 1] + stone[i];
        dpmin[i][i] = 0;
        dpmax[i][i] = 0;
    }
    for(int i = 1;i<=n;i++){
        sum[i+n] = sum[i+n-1]+stone[i];//展开的n后面的n-1~1重量
        dpmin[i+n][i+n] = 0;
        dpmax[i+n][i+n] = 0;
    }
    for(int len = 1;len<=n;len++){//长度还是最大n
        for(int j = 1;j+len<=2*n;j++){//起点枚举最大到2*n-1,ends<=2*n-1
            int ends = j+len - 1;
            for(int i = j;i<ends;i++){//注意！i<ends！！！因为i=ends时，dp[ends+1][ends]是不成立的！
                dpmin[j][ends] = min(dpmin[j][ends],dpmin[j][i]+dpmin[i+1][ends]+sum[ends]-sum[j-1]);
                dpmax[j][ends] = max(dpmax[j][ends],dpmax[j][i]+dpmax[i+1][ends]+sum[ends]-sum[j-1]);
            }
        }
    }
    int ansmin = 0xfffffff;
    int ansmax = -1;
    for(int i = 1;i<=n;i++){
        ansmin = min(ansmin,dpmin[i][i+n-1]);//找1~n,2~n~1,3~n~2....的合并n个堆的中最大和最小的值
        ansmax = max(ansmax,dpmax[i][i+n-1]);
    }
    cout<<ansmin<<endl;
    cout<<ansmax<<endl;
    return 0;
}

这种做法会超时

 

四边形优化，n^2

思路：在查找最优分割点的时候，我们浪费了大量时间。那么我们可以把最优分割点保存下来，在查找的时候利用保存的最优分割点来优化查找过程。

四边形不等式优化：

（1）功能：用来寻找，s[i][j](i~j的最优分割点）与其他分割点的关系

（2）不等式内容：如果某东西满足a<b<=c<d且f[a][c]+f[b][d]<=f[a][d]+f[b][c],则说这个东西满足四边形不等式。简而言之：交叉小于包含！

（3）结论关系：s[i][j-1]<=s[i][j]<=s[i+1][j] 

（4）证明过程：

 0.证明w满足四边形不等式，这里w是m的附属量，形如m[i,j]=opt{m[i,k]+m[k,j]+w[i,j]}，此时大多要先证明w满足条件才能进一步证明m满足条件

 1.证明m满足四边形不等式

 2.证明s[i,j-1]≤s[i,j]≤s[i+1,j]

/*
可以环形的组合 
N堆石子摆成一个环。现要将石子有次序地合并成一堆。
规定每次只能选相邻的2堆石子合并成新的一堆，
并将新的一堆石子数记为该次合并的代价。计算将N堆石子合并成一堆的最小代价。
51node 1022
 
*/ 
#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
#define INF 0x3f3f3f
int dp[2005][2005];
int sum[2005];
int relation[2005][2005];
int num[2005];
int main()
{
    int n;
    scanf("%d",&n);
    memset(sum,0,sizeof(sum));
    memset(dp,0x3f,sizeof(dp));
    for(int i = 1;i<=n;i++){
        scanf("%d",&num[i]);
        dp[i][i] = 0;
        relation[i][i] = i;
        sum[i] = sum[i-1] + num[i];
    }
    for(int i = 1;i<=n;i++){
        sum[i+n] = sum[i+n-1] +num[i];
        relation[i+n][i+n] = i+n;//分割点初始化
        dp[i+n][i+n] = 0;
    }
    for(int len = 1;len<=n;len++){
        for(int j = 1;j+len<=2*n+1;j++){
            int ends = j+len - 1;
            for(int k = relation[j][ends-1];k<=relation[j+1][ends];k++){//k的范围
                if(dp[j][ends]>dp[j][k]+dp[k+1][ends]+sum[ends]-sum[j-1])
                {
                    dp[j][ends]=dp[j][k]+dp[k+1][ends]+sum[ends]-sum[j-1];
                    relation[j][ends] = k;
                }
            }
        }
    }
    int ans = 0xfffffff;//一定要开0xfffffff不然错QAQ
    for(int i = 1;i<=n;i++){
        ans = min(ans,dp[i][i+n-1]);
    }
    printf("%d\n",ans);
    return 0;
}

 

/*
poj 2955
(1)题意：给出一个的只有'(',')','[',']'四种括号组成的字符串，求 
最多 有多少个括号满足题目里所描述的完全匹配。
(2)思路：这里的状态转移是以一个if为基础的，如果s[i]与s[j]匹配，
那么明显的dp[i][j] = dp[i+1][j-1]+2;然后在这个基础上枚举分割点k.
(3)状态转移方程：dp[i][j]表示第i~j个字符间的最大匹配字符数。
if(s[i] 与 s[j]匹配） dp[i][j] = d[[i+1][j-1] +2;
dp[i][j] = max(dp[i][j],dp[i][k]+dp[k+1][j]);
*/
#include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;
const int N=1100;
char s[N];
int dp[N][N];
int main()
{
	while(scanf("%s",s+1)==1){
		if(s[1]=='e') break;
		memset(dp,0,sizeof(dp));
		int n=strlen(s+1);
		for(int len=1;len<=n;len++){
			for(int j=1;j+len<=n+1;j++){
				int end=j+len-1;
				if((s[j]=='('&&s[end]==')')||(s[j]=='['&&s[end]==']')){
					dp[j][end]=dp[j+1][end-1]+2; 
				}
				for(int i=j;i<end;i++){
					dp[j][end]=max(dp[j][end],dp[j][i]+dp[i+1][end]);
				}
			}
		}
		printf("%d\n",dp[1][n]);
	}
	return 0;
} 

 

/*
poj 1651
（1）题意：给你n个数字，要求不能删除两端点的数字，
然后删除其他数字的代价是该数字和左右相邻数字的乘积，
问把数字（除端点）删完后的最小总代价。
（2）思路：因为最后都要删掉中间所有的数字，所以我们分隔一个个小区间删数字，
合并区间求最小。那么我们的状态就是目前删掉的数字区间，但是我们分割的时候的意思是抽一个卡片出来，
所以这个卡片不能在已经抽出的状态里面，所以dp[i][j]里面是不包含j卡片的！
（3）状态转移方程：dp[i][j]表示抽出第i~j-1张卡片时候的最小值
dp[i][j] = min(dp[i][j],dp[i][k] + dp[k+1][j] +num[i-1]*num[k]*num[j]);

因为开始知道这个题的DP方程和矩阵连乘的DP方程一样，所以一直根据方程想思路，
结果想了很久都没想出来，最后看了评论区的大神提示，瞬间想通。看来自己实力还是很渣渣啊。。唉
我们假设只有a1,a2,a3三个数，那我们只能取a2，那最后的得分=a1*a2*a3;  
假如有n个数，设k为最后一个取出来的数，那么，最后一次的得分只与a1,an,ak有关，那么我们把整个区间以k分成两段，左边一段的最后一次得分必然为a1*ak*ai(i>1 &&i<k)，
也就是说左边的得分与右边怎么取无关，
那么我们总得分dp[1][n]=dp[1][k]+dp[k][n]+a[1]*a[k]*a[n];
于是我们可以得出递归方程dp[i][j]=dp[i][k]+dp[k][i]+a[i]*a[k]*a[j]. 
这个方程和矩阵连乘问题的方程基本一样

*/

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
int dp[110][110];
int val[110];
const int inf=0x3f3f3f3f;
int main()
{
	int n;scanf("%d",&n);
	memset(dp,inf,sizeof(dp));
	for(int i=1;i<=n;i++){
		scanf("%d",&val[i]);
		dp[i][i]=0;
	}
	for(int len=1;len<=n;len++){
		for(int i=2;i+len<=n+1;i++){
			int end=i+len-1;
			for(int k=i;k<end;k++){//                               这里是i-1 因为不算第一个 
				dp[i][end]=min(dp[i][end],dp[i][k]+dp[k+1][end]+val[i-1]*val[k]*val[end]);
			}
		}
	}
	printf("%d\n",dp[2][n]);
	return 0;
}