动态规划--区间dp

于 2022-11-18 17:41:17 发布
阅读量603 收藏 2
点赞数
分类专栏： 动态规划 文章标签： 动态规划 算法 贪心算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60343477/article/details/127897346
版权

区间dp

题目列表：

(1)石子合并

在复习石子合并之前，为了直接进入专题“区间dp“，做一个区间dp的基础题，这个题目具有代表性：(题目用到了前缀和，前缀和看这里： ）

  1. 使用了区间dp的模板
  2. 清晰理解区间dp的思想

区间dp：将问题分为若干区间，不断解决小区间，最终延展到整个问题的区间，即：一个问题的范围是一个很大的区间，那么通过不断解决小区间，延伸到解决大区间
在这里插入图片描述

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N = 310,INF=0x3f3f3f3f;

int f[N][N];  //f[i][j]表示区间i到j的石子合并的最小代价。那么最终问题的解就是f[1][n]表示第一个石子到最后一个石子合并的最小代价
//dp问题三部曲：
//（1）集合定义，即dp[i][j]表示什么，是否合理  （2）dp初始化，由于dp要往后面推，那么dp就要有初始值，0生1，1生2，3生3，3生万物
//（3）dp的状态转移，即当前dp的下一步要解决什么事情（也叫状态转移方程组）

int w[N];  //存储石子的重量
int pre[N];   //石子堆的前缀和
int n;
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> w[i];
		pre[i] = pre[i - 1] + w[i];
	}
		

	for (int i = 1; i <= n; i++)
		f[i][i] =0;      //区间为1的石子无法合并，所以消耗的体力就是0

	for (int len = 2; len <= n; len++)  //枚举区间长度
	{
		for (int L = 1; L + len - 1 <= n; L++)//(L+len-1)表示长度为len的区间的右端点
		{
			int R = L + len - 1;     //右端点
			f[L][R] = INF;  //因为要求最小值，先预先设置一个最大值
			for (int k = L; k <R; k++)   //将当前长度区间分为两个部分，求两个部分的最小值（因为区间合并的最后一步就是将两个石子堆合并为一个石子堆）
			{
				f[L][R] = min(f[L][R], f[L][k] + f[k + 1][R] + pre[R] - pre[L - 1]); //f[L][R]的最小价值等于两个部分的最小值加上整个区间的重量
			}
		}
	}
	cout << f[1][n];
	return 0;
}

(2)环形石子合并

在这里插入图片描述

这题于上一个题的唯一区别在于：这是环形，首尾的石子可以先合并。那么就使用一种”化曲为直“的思想。将环形结构拉直变成线性结构：
将数组扩大两倍，后面部分复制一遍数据即可模拟环形结构。

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 410,INF=0x3f3f3f3f;

int f[N][N];   //f[i][j]表示区间[i,j]的石子合并消耗的最小体力。
int g[N][N];   //g[i][j]表示区间[i,j]的石子合并消耗的最大体力
int pre[N];   //pre[i]表示前i个石子的重量和
int w[N];   //石子重量   
int n;
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> w[i];
	for (int i = n + 1; i <= 2 * n; i++)  //化曲为直的操作
		w[i] = w[i - n];
	for (int i = 1; i <= 2 * n; i++)
	{
		pre[i] = pre[i - 1] + w[i];
	}

	//初始化
	for (int i = 1; i <= n * 2; i++)
		f[i][i] = g[i][i] = 0;

	for (int len = 2; len <= n; len++)
	{
		for (int l = 1; l + len - 1 <= 2 * n; l++)
		{
			int r = l + len - 1;
			f[l][r] = INF;   //求最小值给最大值
			g[l][r] = -INF;   //求最大值给最小值
			for (int k = l; k < r; k++)
			{
				f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + pre[r] - pre[l - 1]);
				g[l][r] = max(g[l][r], g[l][k] + g[k + 1][r] + pre[r] - pre[l - 1]);
			}
		}
	}
	int res = INF; 
	int ans = -INF;
	for (int i=1; i + n - 1 <= 2 * n; i++)
	{
		res = min(res, f[i][i + n - 1]);
		ans = max(ans, g[i][i + n - 1]);
	}
	cout << res <<endl<< ans;
	return 0;
}

(3)能量项链

在这里插入图片描述
大致题意：
每个珠子都有两面，一面一个值。有n个珠子，首尾相连，且任意相邻的两个珠子的邻接面的值是一样的，两颗珠子可以合并为一个珠子，且释放能量。
给一个示例：

（1，2） （2，3）（3，4）（4，1） 4颗珠子，首尾相连且满足相邻的值一样。有点像矩阵相乘
其中一种组合方法：
（1，2）和（2，3）组合变成(1,3),释放能量1x2x3
（1，3）和（3，4）组合变成(1,4),释放能量1x3x4
（1，4）和（4，1)组合变成(1,1)，释放能力1x4x1
没有珠子可以合并了，发现一共合并3次，释放能量：6+12+4=22.但是不是最优解就不知道了。因为从不同的珠子为起点来合并答案都不一样.

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=1100,INF=0x3f3f3f3f;
typedef long long ll;
ll f[N][N];   //f[i][j]表示区间[i,j]的石子合并的最大能量,最后的答案是f[1][n+1]
int w[N*2];
int n;


int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&w[i]);
        w[i+n]=w[i];
    }
    
    //dp初始化
    for(int i=1;i<n*2;i++)   //长度为2的区间代表一个石子，不能合并，从定义出发那就意味着没有能量。
        f[i][i+1]=0;
    
    for(int len=3;len<=n+1;len++) //枚举长度，什么是n+1，因为3个石子的区间长度是4
    {
        for(int l=1;l+len-1<=n*2;l++)  //枚举左端点
        {
            int r=l+len-1;  //右端点
            f[l][r]=-INF;
            for(int k=l+1;k<r;k++)  //区间分段求最大，分段要注意细节，根据事实来分,这里的细节是：长度为1的区间没有意义  2 3 4 5
            {
                f[l][r]=max(f[l][r],f[l][k]+f[k][r]+w[l]*w[r]*w[k]);
            }
        }
    }
    
    
    ll res=0;
    for(int i=1;i+n<=2*n;i++)  //枚举左端点求最大值
    {
        res=max(res,f[i][i+n]);  //搞不清这个是n还是n+1的时候举个例子。比如n==3，  1 2 3 1 2 3.要选取4个数,保证首尾相同
    }
    cout<<res;
    return 0;
}

(4)加分二叉树

在这里插入图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N=50,INF=0x3f3f3f3f;

int w[N];
int f[N][N];  //f[i][j]表示区间[i,j]的子树的最大值
int path[N][N];  //path[i][j]表示子树[i,j]的根节点

int n;


void dfs(int l,int r)  //求前序遍历
{ 
    if(l>r)return;
    int k=path[l][r];
    printf("%d ",k);
    dfs(l,k-1);
    dfs(k+1,r);
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>w[i];
        
    //初始化
    for(int i=1;i<=n;i++)
    {
        f[i][i]=w[i];   //一个节点的最大能量就是当前节点值
        path[i][i]=i;  //叶子节点没有子树，的根节点就是自己
    }
    
    //dp的思路是：枚举所有长度的子树，且求出字典序最小的根节点
    for(int len=1;len<=n;len++)   //枚举长度
    {
        for(int l=1;l+len-1<=n;l++)  //枚举左端点
        {
            int r=l+len-1;  //右端点
            f[l][r]=-INF;
            for(int root=l;root<=r;root++)  //枚举根节点
            {
                int left=root==l?1:f[l][root-1];
                int right=root==r?1:f[root+1][r];
                int temp=left*right+w[root];
                if(l==r)
                    temp=w[root];
                if(temp>f[l][r])  //因为原先的树是12345，所以保证字典序的最小就是保证每次的根节点最小就好了。因为四前序遍历
                {
                    f[l][r]=temp;
                    path[l][r]=root;
                }
            }
        }
    }
    cout<<f[1][n]<<endl;
    dfs(1,n);
    return 0;
}

(5)凸多边形的划分

在这里插入图片描述
这个题目不用高精度只能过几个点，所以用高精度
先上一个不用高精度的，能过三个数据：

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;

const int N = 100,INF=0x3f3f3f3f;

long long int f[N][N];  //f[i][j]表示区间[i,j]的权值最大值
int w[N];    //每个点的权值
int n;
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> w[i];

	//初始化
	for (int i = 1; i <n; i++)  //两个点不能连接三角形，所以权值为0
		f[i][i + 1] = 0;
	for (int len = 3; len <= n;len++)  //枚举区间   ,,为什么不要做环形处理，要看定义，这里的定义是区间[i,j]内划分三角形的最大价值
		for (int l = 1; l + len - 1 <= n; l++)  //枚举左端点
		{
			int r = l + len - 1;
			if (len == 3)
			{
				f[l][r] = w[l] * w[l+1] * w[r];
				continue;
			}
			f[l][r] = INF;
			for (int k = l + 1; k < r; k++)
			{
				f[l][r] = min(f[l][r], f[l][k] + f[k][r]+w[l]*w[r]*w[k]);
			}
		}
	cout << f[1][n];
	return 0;
}

下面是高精度：

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>
#include<cstdio>

using namespace std;
typedef long long ll;
const int N=51,M=35,INF=0x3f3f3f3f;

vector<int>f[N][N];  //状态表示：f[i][j]表示一个一个一维数组，存放一个高精度的值，他的意义是左端点是i，右端点是j的封闭的多边形的最大价值
int w[N];   //存储点
int n;


void pre(vector<int>& s,int t)   //先假设一个数，边看这个数边来模拟就不容易出错。example:1234
{
    //将t放入s
    while(t)
    {
        s.push_back(t%10);
        t/=10;
    }
}

bool cmp(vector<int>&a ,vector<int>&b)  //比较f[l][r]和f[l][k]+f[k][r]+w[l]*w[k]*w[r]哪个小,规定a>b,返回true
{
    if(a.size()!=b.size())
    {
        if(a.size()>b.size())
            return true;
        else
            return false;
    }
    else
    {
        //说明两个数组长度一样
        for(int i=a.size()-1;i>=0;i--)  //逆序比较
        {
            if(a[i]!=b[i])  //高位比较，如果a[i]大于b[i]，则a>b
                return a[i]>b[i];
        }
        return true;//相等的情况
    }
      
}

vector<int> mul(vector<int>&a,ll b)//123 12
{
    vector<int>c;
    ll t=0;
    for(int i=0;i<(int)a.size();i++)
    {
        t+=b*a[i];
        c.push_back(t%10);
        t/=10;
    }
    while(t)
    {
        c.push_back(t%10);
        t/=10;
    }
    return c;
}

vector<int>add(vector<int>&a,vector<int>&b)
{
    vector<int>c;
    ll t=0;
    for(int i=0;i<a.size()||i<b.size();i++)
    {
        if(i<a.size())t+=a[i];
        if(i<b.size())t+=b[i];
        c.push_back(t%10);
        t/=10;
    }
    while(t)
    {
        c.push_back(t%10);
        t/=10;
    }
    return c;
    
    
}

int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)cin>>w[i];
    //初始化dp,dp[i][i+1]=0,因为两条边是不能构成回路的，多边形必须要3条边或者说3个点才可以构成回路
    vector<int>temp;
    for(int len=3;len<=n;len++)
    {
        for(int i=1;i+len-1<=n;i++)  //枚举左端点
        {
            int j=i+len-1;  //右端点
            //因为要求f[l][r]的最小值,所以将其先预先设置为无穷大，
            f[i][j]=vector<int>(M,9);
        
            for(int k=i+1;k<j;k++)  //k能枚举到i+1到j-1，
            {
                //目的是求f[i,k]+f[k,j]+w[i]*w[k]*w[j];
                //先求乘法
                temp.clear();
                temp.push_back(w[i]);  //高精度相加，那么是3个数组的加法，需要将具体的数字都放在数组里面，先将第一个数放在数组里面
                //cout<<temp[0]<<temp[1]<<temp[2]<<endl;
                temp=mul(temp,w[k]);
                temp=mul(temp,w[j]);   //到这里就完成了乘法了
                temp=add(temp,f[i][k]);
                temp=add(temp,f[k][j]);
                //到这里就完成了加法和乘法的累和
                if(cmp(f[i][j],temp))  //如果temp小于等于f[i][j]
                    f[i][j]=temp;
            }
            
        }
    }
    for(int i=f[1][n].size()-1;i>=0;i--)
        cout<<f[1][n][i];
    return 0;
}

(6)棋盘分割

记忆化dp，将棋盘进行分割，分别有两种情况。要么竖着切，要么横切。
然后取一边继续切割。最后回溯的时候取两边的最小值即可

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int N=16;
double f[N][N][N][N][N];  //f[k][x1][y1][x2][y2]表示对棋盘进行了k次划分，得到的左上角是(x1,y1),右下角是(x2,y2)的棋盘的最小分值

int n,m=8;
int s[N][N];  //前缀和
double x;

double get(int x1,int y1,int x2,int y2)
{
    double delta=s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1];  //计算当前矩阵的分值和
    delta=delta-x;
    return delta*delta;
}


double dp(int k,int x1,int y1,int x2,int y2)
{
    if(f[k][x1][y1][x2][y2]>=0)return f[k][x1][y1][x2][y2];  //记忆化搜索的关键
    if(k==n) return f[k][x1][y1][x2][y2]=get(x1,y1,x2,y2);   //最后一次不需要继续切了，直接返回当前的矩阵
    
    double t=1e9;  
    for(int i=x1;i<x2;i++)  //横切
    {
        t=min(t,dp(k+1,x1,y1,i,y2)+get(i+1,y1,x2,y2));  //取上半部分继续切，那么下半部分分值加起来
        t=min(t,dp(k+1,i+1,y1,x2,y2)+get(x1,y1,i,y2));
    }
    
    for(int i=y1;i<y2;i++)  //竖切
    {
        t=min(t,dp(k+1,x1,y1,x2,i)+get(x1,i+1,x2,y2));  //取左边继续切
        t=min(t,dp(k+1,x1,i+1,x2,y2)+get(x1,y1,x2,i));
    }
    return f[k][x1][y1][x2][y2]=t;
}


int main()
{
    cin>>n;
    for(int i=1;i<=m;i++)
        for(int j=1;j<=m;j++)
            scanf("%d",&s[i][j]);
    for(int i=1;i<=m;i++)   //二维前缀和
        for(int j=1;j<=m;j++)
            s[i][j]=s[i][j]+s[i-1][j]+s[i][j-1]-s[i-1][j-1];
    
    memset(f,-1,sizeof f);
    x=(double)s[m][m]/n;
    printf("%.3lf",sqrt(dp(1, 1, 1, m, m) / n));
    return 0;
    
}

好了，区间dp到此为止。明天树形dp见。

哆啦刘小洋
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
石子合并 区间dp
WananRd
06-03 983
前缀和、区间dp
ACwing 282 - 石子合并（区间DP）
在读NLP硕士
09-14 163
设有N堆石子排成一排，其编号为1，2，3，…，N。 每堆石子有一定的质量，可以用一个整数来描述，现在要将这N堆石子合并成为一堆。 每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。 例如有4堆石子分别为 1 3 5 2， 我们可以先合并1、2堆，代价为4，得到4 5 2， 又合并 1，2堆，代价为9，得到9 2 ，再合并得到11，总代价为4+9+11=24； 如果第二步是先合并2，3堆，则代价为7，得到4 7，
动态规划之区间DP详解
晨的博客
09-08 1082
区间DP
石子合并（区间dp）
moyangxian
04-27 208
题目链接 设有N堆石子排成一排，其编号为1，2，3，…，N。 每堆石子有一定的质量，可以用一个整数来描述，现在要将这N堆石子合并成为一堆。 每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。 例如有4堆石子分别为 1 3 5 2， 我们可以先合并1、2堆，代价为4，得到4 5 2， 又合并 1，2堆，...
算法-动态规划- 区间 DP（包含源程序）.rar
09-16
算法-动态规划- 区间 DP（包含源程序）.rar
richenyunqi#code-templates#区间动态规划1
07-25
边界条件：$dp[i][i]=0$算法的时间复杂度为$O(n^3)$C++代码：++len) { //枚举区间长度++left) { //枚举左端点//右端点。
算法-动态规划- 区间 DP- 石子合并三讲（包含源程序）.rar
09-16
算法-动态规划- 区间 DP- 石子合并三讲（包含源程序）.rar
mythsman#blog-source#区间dp专题小结1
07-25
区间DP是一类在区间上进行动态规划的最优问题，一般是根据问题设出一个表示状态的dp，可以是二维的也可以是三维的，一般情况下为二维。然后将问题划分成两个子问题，也
StrongPosHao#LearningProcessRecord#动态规划-最长不含重复字符的子字符串1
07-25
当i , 即s[j]左边无相同字符，则dp[j] = dp[j-1] + 1当dp[j-1] >= j-i，说明字符s[i]在子字符串dp[j-1]区间之
动态规划(区间dp）
shaohang_的博客
07-18 247
  B - Brackets 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]...
动态规划—区间DP
正在考研ing
03-30 1249
AcWing算法提高课内容，本文讲解 动态规划 本篇包括以下题目： AcWing 1068. 环形石子合并 AcWing 320. 能量项链 AcWing 479. 加分二叉树 AcWing 1069. 凸多边形的划分 写博客有哪里不完善的地方或者有哪里表达错误希望大家提出来，博主会立即改正！望大家海涵 本文需要先自修基础：区间DP
区间动态规划详解
u012679087的专栏
11-15 4921
前段时间遇到石子合并问题，看着题解A了，以为学会了区间DP，再次遇到能量项链这个问题的时候大脑还是一片空白，只能重新认识一下区间动态规划了。 翻过很多博客，基本上都是题解，真正对区间动态规划本身的讲解几乎没有，可能是我没找到吧。   区间动态规划，顾名思义，就是动态规划过程中求一个区间的最优解。通过将一个大的区间分为很多个小的区间，求其小区间的解，然后一个一个的组合成一个大的区间而得出最终解...
动态规划（4）区间dp
weixin_64197656的博客
09-07 349
简单区间dp
区间dp动态规划（上篇）
02-22 200
今天的主题就是这个啦（感谢我亲爱的学校，让我能翘晚自习搞信息）。 区间dp就是在一个很窄很窄的矩阵里面（线性结构）（我写的都是我自己的理解，语言毫无规范可言）进行的操作，将它按特定要求分割开来，然后不同地方分割会有不同的收益，而我们的目标是让这个收益值最大（通常，话不能说太满）。 先上个模板（我用的是c++） vector<vector<int>> dp(n, (n, 0)); // 定义+初始化（用vector是因为初始化方便，它跟数组没太大区别） int j; /
动态规划之区间DP详细介绍和例题练习
Carroll的博客
05-05 244
区间DP 区间DP例题 石子合并 import java.util.*; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); int N = in.nextInt(); in.nextLine(); String[] s = in.nextLine().split(" ");
动态规划：区间DP（学习记录）
m0_62289613的博客
11-25 342
可以说是第一部分自学的内容吧，一开始是因为在oj上碰到了类似的题，新生赛（不愿再回忆。。。）也有一个题用到了这一部分知识，来看看吧。（这一篇有很多想写的，希望不会鸽掉） 例题： 1045 石子合并1 1048 石子合并2 1178 能量项链 U187635 刷墙（easy） 1187 矩阵取数 区间DP：区间类动态规划是线性动态规划的扩展，它在分阶段地划分问题时，与阶段中元素出现的顺序和由前一阶段的哪些元素合并而来有很大的关系。（来自区间 DP - OI Wiki (oi-w...
【算法基础】区间动态规划 例题与解析
wayne_lee_lwc的博客
06-03 1019
好的小伙伴们，疯狂鸽鸽的卷卷毛来了，今天来分享的，区间动态规划，简称区间dp(dynamicprogramming)(dynamic programming)(dynamicprogramming)，是动态规划的一种。就是动态规划其中一种模型：区间dp 提到动态规划，它是我们在算法题目中常见到的老朋友了，也往往是思维难度相对较大题目的解决核心，潘子就告诉过我们：“动态规划水很深，你把我不住” 引起这个问题的原因有很多，一个常见的情况就是：动态规划算法题目往往会引起贪心算法的直觉。而一旦将思路限制在贪心算法
（转）dp动态规划分类详解
weixin_33725239的博客
08-24 88
dp动态规划分类详解 转自：http://blog.csdn.NET/cc_again/article/details/25866971 动态规划一直是ACM竞赛中的重点，同时又是难点，因为该算法时间效率高，代码量少，多元性强，主要考察思维能力、建模抽象能力、灵活度。 ********************************************************...
动态规划实现区间调度
最新发布
05-25
动态规划是一种常用的解决区间调度问题的算法。在区间调度问题中，我们需要从多个区间中选出不相交的区间，使得选出的区间数量最大。下面是动态规划实现区间调度的步骤： 1. 按照区间的结束时间对所有区间进行排序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值