区间dp小结

最新推荐文章于 2023-04-26 09:11:33 发布
置顶 最新推荐文章于 2023-04-26 09:11:33 发布
阅读量408 收藏 1
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NOI_yzk/article/details/78379742
版权

序：这次的专题刷得很蛋疼有趣 各种大神代码和题解
区间dp，异于普通的线性dp，它的转移往往是建立于不同的规则上且诡异复杂的
区间dp的解题要点是找到一种转移使得我们能够得到最优解

HDU4283
因为要保持栈的合法，所以不能排序乱排瞎搞
取一段区间，可以保证区间的做端点能在该区间的任意点后出去
那么利用这一点，就可以来更新区间

for(int i=1;i<=n;i++){
    scanf("%d",&A[i]);
    Sum[i]=Sum[i-1]+A[i];
    dp[i][i]=0;
}
for(int i=1;i<=n;i++)
    for(int j=i+1;j<=n;j++)dp[i][j]=1e9;
for(int l=1;l<n;l++){
    for(int i=1;i<=n-l;i++){
        int j=l+i;
        for(int k=1;i+k-1<=j;k++){
            dp[i][j]=Min(dp[i][j],dp[i+1][i+k-1]
     +dp[i+k][j]+(Sum[j]-Sum[i+k-1])*k+A[i]*(k-1));
        }
    }
}

HDU4293
这题不能算是一道实际意义上的区间dp
但我们要在这道题中发觉每个人对应的只有一个区间
那么我们应该选取几段不相交区间使得答案最大
记第i个点前最优解为dp[i]
可得状态转移方程为dp[i]=max(dp[i],dp[j]+sum[i][j])

for(int i=1;i<=n;i++){
    int l,r;
    scanf("%d%d",&l,&r);
    if(l+r>n||Sum[l+1][n-r]==n-r-l)continue;
    Sum[l+1][n-r]++;
}
for(int i=1;i<=n;i++)
    for(int j=1;j<=i;j++)
        Tmp[i]=Max(Tmp[i],Tmp[j-1]+Sum[j][i]);
    //Tmp[i]表示i前最多人数
    //Sum[i][j]表示区间[i,j]内最多站的人数

HDU4412
据说这是整个专题中最难的题目具体的一些细节自己也没搞清楚
这题的主要解题思路为我们可以贪心地求出一段区间只去一个大本营的最小期望
然而这里是可以优化时间复杂度的
首先针对一个区间[l,r]，他的上一个区间[l,r-1] 大本营的地点要么不变，要么就会往右移，所以找大本营的位置是O(1)[均摊]的
然后利用前缀和也可O(1)求出Cost[i][j]
最后的dp转移就十分轻松了O(n*n*m)
参照Komachi神犇代码

#include<bits/stdc++.h>
using namespace std;
#define M 1005
map<int,double>mp;
int Way[M];
double P[M],Val[M],Sum[M],Cost[M][M],dp[55][M];

int main(){
    int n,m;
    while(~scanf("%d%d",&n,&m)&&(n||m)){
        mp.clear();
        //read
        for(int i=1;i<=n;i++){
            int tmp;
            scanf("%d",&tmp);
            for(int k=1;k<=tmp;k++){
                int a;double b;
                scanf("%d%lf",&a,&b);
                mp[a]+=b;
            }
        }
        //init
        int n=0;
        for(map<int,double>::iterator it=mp.begin();it!=mp.end();++it){
            Way[++n]=it->first,P[n]=it->second;
        }
        for(int i=1;i<=n;i++){
            Sum[i]=Sum[i-1]+P[i]*Way[i];
            Val[i]=Val[i-1]+P[i];
        }
        for(int i=1;i<=n;i++){
            int p=i;
            for(int j=i;j<=n;j++){
                while(p<j&&Val[p]*2<(Val[i-1]+Val[j]))p++;
                Cost[i][j]=Way[p]*(Val[p]-Val[i-1])-Way[p]*(Val[j]-Val[p])+
                (Sum[j]-Sum[p])-(Sum[p]-Sum[i-1]);
            }
        }
        //dp
        for(int i=0;i<=m;i++)for(int j=1;j<=n;j++)dp[i][j]=1e15;
        for(int i=0;i<=m;i++)dp[i][0]=0;
        for(int i=1;i<=m;i++){
            for(int j=1;j<=n;j++){
                for(int k=0;k<j;k++){
                    dp[i][j]=min(dp[i][j],dp[i-1][k]+Cost[k+1][j]);
                }
            }
        }
        printf("%.2lf\n",dp[m][n]);
    }
    return 0;
}

求p的那部分实在看不懂完全可以用代替

Way[p]*(Val[p]-Val[i-1])-Way[p]*(Val[j]-Val[p])-2*Sum[p]>
Way[p+1]*(Val[p+1]-Val[i-1])-Way[p+1]*(Val[j]-Val[p+1])-2*Sum[p+1]

HDU4597
网上题解全是记忆化搜索
献上一个递推的：

#include<bits/stdc++.h>
using namespace std;
int dp[25][25][25][25];
int A[25],B[25],Sum[25],Tmp[25];

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        int n;
        scanf("%d",&n);
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++) scanf("%d",&A[i]),Tmp[i]=Tmp[i-1]+A[i];
        for(int i=1;i<=n;i++) scanf("%d",&B[i]),Sum[i]=Sum[i-1]+B[i];

        for(int i=n+1;i>=1;i--){
            for(int j=i-1;j<=n;j++){
                for(int k=n+1;k>=1;k--){
                    for(int h=k-1;h<=n;h++){
                        int tot=Sum[h]-Sum[k-1]+Tmp[j]-Tmp[i-1];
                        if(i<=j)dp[i][j][k][h]=max(dp[i][j][k][h],tot-dp[i+1][j][k][h]);
                        if(k<=h)dp[i][j][k][h]=max(dp[i][j][k][h],tot-dp[i][j][k+1][h]);
                        if(k<=h)dp[i][j][k][h]=max(dp[i][j][k][h],tot-dp[i][j][k][h-1]);
                        if(i<=j)dp[i][j][k][h]=max(dp[i][j][k][h],tot-dp[i][j-1][k][h]);
                    }
                } 
            }
        }
        printf("%d\n",dp[1][n][1][n]);
    }
    return 0;
}

HDU4745
刚开始看到这道题的时候是懵逼的
兔子可以转圈，那怎么搞，for循环都不好实现
后来发现其实把序列扩展成两倍就好了，因为兔子最多跳一圈
然后可以发现兔子的跳法就是最长回文子序列
其实感觉求答案的那部分还是很巧妙的
兔子可以挑任一点开始跳，那么区间的起点就可以任意取
即dp[i][i+n-1]或dp[i][i+n-2]+1【从同一点出发】

for(int i=1;i<=n;i++){
    scanf("%d",&A[i]);
    A[i+n]=A[i];
    dp[i][i]=1;
}
int ans=0;
for(int i=2*n;i>=1;i--){
    for(int j=i+1;j<=2*n;j++){
        dp[i][j]=max(dp[i][j-1],dp[i+1][j]);
        if(A[i]==A[j]){
            dp[i][j]=max(dp[i][j],dp[i+1][j-1]+2);
        }
    }
}
for(int i=1;i<=n;i++){
    ans=max(ans,dp[i][i+n-1]);
    ans=max(ans,dp[i][i+n-2]+1);  //两只兔子从同一个起点出发
}

HDU5115
一道很经典的区间dp，特别有套路
枚举一个区间内，哪个点最先被打，然后更新最大值

for(int i=1;i<=n;i++)scanf("%d",&A[i]);
for(int i=1;i<=n;i++)scanf("%d",&F[i]);
for(int i=n;i>=1;i--){
    for(int j=i;j<=n;j++){
        if(i==j)dp[i][j]=A[i]+F[i-1]+F[i+1];
        else{
            dp[i][j]=1e9;
            for(int k=i;k<=j;k++){
                dp[i][j]=min(dp[i][j],dp[i][k-1]+dp[k+1][j]+F[i-1]+A[k]+F[j+1]);
            }
        }
    }
}

HDU5396
仔细领会网上的题解还是比较容易理解的
下面是我个人的见解

将dp[i][k]的方案数拆开,分别为(a1+a2+a3+a4+a5+…+a[(k-i)!])
同理dp[k+1][j]的方案数为(b1+b2+b3+…+b[(j-k-1)!])
若要把dp[i][k]与dp[k+1][j]相加，则要将dp[i][k]与dp[k+1][j]中所有元素相加
那么dp[i][k]中的每个元素要被加(j-k+1)!次 同理dp[k+1][j]中每个元素要被加(k-i)!次
所以为加号时res=dp[i][k](j-k+1)!+dp[k+1][j](k-i)! 为减号时同时满足这个规律 但为乘号时
可以发现res=(a1+a2+a3+…+a[(k-i)!])*(b1+b2+b3+…+b[(j-k+1)!])刚好是所有方案数两两相乘
合并完dp[i][k]和dp[k+1][j]后 我们可以保证dp[i][k]与dp[k+1][j]各自的运算符都是有序的
但他们之间运算符的顺序并没有确定 因为C[k]是最后的运算符，所以C[k]做为最后运算符得到的最终答案 为
res*C(j-i-1,k-i)

代码实现（注意阶乘预处理时fact[0]=1）：

void init(){
    c[0][0]=1;
    for(int i=1;i<=100;i++){
        c[i][0]=c[i][i]=1;
        for(int j=1;j<=i;j++){
            c[i][j]=c[i-1][j-1]+c[i-1][j];
            c[i][j]%=P;
        }
    } 
    fact[0]=1;
    fact[1]=1;
    for(int i=2;i<=100;i++)fact[i]=fact[i-1]*i%P;
}
int main(){
    int n;
    init();
    while(~scanf("%d",&n)){
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=n;i++)scanf("%d",&A[i]),dp[i][i]=A[i];
        scanf("%s",C+1); 
        for(int i=n;i>=1;i--){
            for(int j=i+1;j<=n;j++){
                for(int k=i;k<j;k++){
                    long long res=0;
                    if(C[k]=='*')res=dp[k+1][j]*dp[i][k]%P*c[j-i-1][k-i]%P;
                    else if(C[k]=='+')res=(dp[i][k]*fact[j-k-1]%P+dp[k+1][j]*fact[k-i]%P)*c[j-i-1][k-i]%P;
                    else res=(dp[i][k]*fact[j-k-1]%P-dp[k+1][j]*fact[k-i]%P)*c[j-i-1][k-i]%P;
                    dp[i][j]=(dp[i][j]+res)%P;
                }
            }
        }
        printf("%lld\n",(dp[1][n]+P)%P);
    }
    return 0;
}

HDU5900
有是一道写法不同于狼群但很有拓展性的题目
两个相邻的不互质的数，可以消除
消除之后一个区间两边的两个点可能就会并到一起
但这要在区间被削完的情况下
不然就可以把区间劈成两半更新最大值

for(int i=1;i<=n;i++)scanf("%d",&A[i]);
for(int i=1;i<=n;i++)scanf("%d",&Val[i]),Sum[i]=Sum[i-1]+Val[i];
for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
        if(gcd(A[i],A[j])!=1)mark[i][j]=1;
        else mark[i][j]=0;
for(int i=n;i>=1;i--){
    for(int j=i;j<=n;j++){
        if(Sum[j-1]-Sum[i]==dp[i+1][j-1]&&mark[i][j])
            dp[i][j]=dp[i+1][j-1]+Val[i]+Val[j];
        else for(int k=i;k<j;k++)chk_mx(dp[i][j],dp[i][k]+dp[k+1][j]);
    }
}

小结：
区间dp还是很有套路的
首先区间dp状态的划分是建立在区间的基础上的，即区间内的状态是可以不用考虑的
然后是更新，区间之间的联系需要结合具体题目，一般是枚举一段区间
然后在枚举这段区间内的一个点进行特殊处理（加上一些值…）
区间dp中的一种特殊类型就是消除，它会使原来无联系(不相邻)的两个区间合并成一个区间，这时一般采用向两边拓展的方式
首先要保证中间这段区间被削完，然后类似于dp[i][j]=dp[i+1][j-1]…

毅者自远！

NOI_yzk
关注
专栏目录
区间dp（模板+例题）
等我，等我变的更好就去找你
06-20 669
参考博文：区间dp小结（附经典例题） 首先，什么是区间dp？它是干什么的？ 先在小区间进行DP得到最优解，然后再利用小区间的最优解合并求大区间的最优解 操作往往涉及到区间合并问题 以上。 模板如下： //mst(dp,0) 初始化DP数组 for(int i=1;i&lt;=n;i++) { dp[i][i]=初始值 } for(i...
状压dp小结
qlq-polo
10-28 509
今天模拟又考了一个SPFA+状压dp，巧了，我又不会，华丽丽爆零。（实际上我啥都不会） 状压dp即用二进制暴力枚举然后状态转移。用f[i][j]表示第i行在状态j的时候的方案数，其中j用一个二进制数来表示。转移的时候只要判断与当前行和上一行(或是上几行)是否冲突即可，如果不冲突，f[i][j]=∑f[i−1][q]其中q为不冲突的状态。∑1≤i≤cnt​f[n][i] 就是最后的答案，cnt为总状...
hdu 5115 Dire Wolf 区间DP
weixin_34315485的博客
03-10 147
Dire Wolf Time Limit: 5000/5000 MS (Java/Others) Memory Limit: 512000/512000 K (Java/Others) Total Submission(s): 439 Accepted Submission(s): 254 Problem Description Dire wolves, also known as Dark wo...
poj1390 Blocks(经典区间dp/消除问题)
小衣同学的博客
04-12 436
题目 思路来源 https://www.cnblogs.com/Tieechal/p/11637638.html清楚明白的讲解 题解 和[Luogu2135] 方块消除及UVA10559 Blocks是一模一样的题目 代码 #include<iostream> #include<cstdio> #include<cstring> us...
hdu6212 Zuma(区间dp+消除问题(含连锁反应))
小衣同学的博客
04-12 292
题目 思路来源 https://blog.csdn.net/Dream_Lolita/article/details/78764613 题解 bzoj1032是这个题的extend版，然而据说是假题orz 代码 #include<iostream> #include<cstdio> #include<cstring> #include<...
区间DP（区间最优解）题目讲解总结
weixin_33719619的博客
08-03 331
1：给出一个括号字符串，问这个字符串中符合规则的最长子串的长度。 【分析】区间DP要覆盖整个区间，那么要求所有情况的并集。 先想出状态方程： dp[i][j]：i ~ j区间内最大匹配数目 输出：dp[0][n-1]（从0开始） 区间DP最先想到的是就是： 1.边界情况初始化 2.for枚举区间长度，一般从第二个开始 3.for枚举起点 4.直接求...
HDU-5115 Dire Wolf(区间dp)
yo_bc的博客
07-12 383
Dire wolves, also known as Dark wolves, are extraordinarily large and powerful wolves. Many, if not all, Dire Wolves appear to originate from Draenor. Dire wolves look like normal wolves, but these creatures are of nearly twice the size. These powerful bea
mythsman#blog-source#区间dp专题小结1
07-25
区间DP是一类在区间上进行动态规划的最优问题，一般是根据问题设出一个表示状态的dp，可以是二维的也可以是三维的，一般情况下为二维。然后将问题划分成两个子问题，也
斜率优化dp小结
Mathon
05-10 8773
单调队列优化在写斜率优化之前，我们来回顾一下单调队列优化的dp 1. 对于如下形式的dp方程 dp[i]=min{dp[j]+f(j)}(0<j<i)dp[i] = min\{dp[j] + f(j)\} (0 < j < i) 我们直接用一个变量维护(0, i)中dp[j] + f(j)的最小值即可2.对于如下形式的dp方程 dp[i]=min{dp[j]+f(j)}(i−m<j<i)dp
区间DP (Java) 解析/模板/案例
最新发布
weixin_45532984的博客
04-26 1135
区间DP，是经常会用到的、解决区间问题的一种方法，经常以动态规划（dfs/记忆化搜索）的形式展现，最核心的思想就是枚举区间（枚举端点），寻找切割点，处理因切割点而产生的结果，进行区间累加或者选取个别区间，从而解决整体的问题。
HDU 5115 Dire Wolf(区间dp)
qq_41997978的博客
04-01 230
这道题，题目大意就是有n头狼排在一起，每头狼有个伤害值，还有个给相邻的狼的伤害加成值，如果杀掉一头狼，受到的伤害是这头狼本身的伤害值加上这头狼受到的加成值。如果杀掉一头狼，那么剩下的狼会继续靠在一起。 这题的转移方程用到了原问题外部的影响。 我最开始是将子问题完全独立出来思考，转移方程不太一样。在这题之前，我做过的dp似乎很少用到更大规模问题的影响,也不能说是影响，就是转移的时候不能将子问题完全独...
区间dp题解
代不在‘的博客
07-27 169
题目链接 题意： 有n个人上台演出，每个人ai有一个diaosi值di，他们的不开心值si会随着自己的出场顺序u而变化, si = di * (u - 1),求最小不开心值总和。 题解: 给的顺序是入栈的顺序。 区间dp ： dp[i][j]表示第i个人到第j个人的最小不开心总值，sum[i]表示前i个数的和。 k表示i ~ j 区间第 i 个人（即 i 到 j 区间第一个人）第 k 个上台表演，...
区间DP——Dire Wolf ( HDU 5115 )
FeBr2的博客
08-25 450
题目链接： http://acm.split.hdu.edu.cn/showproblem.php?pid=5115 参考链接： http://blog.csdn.net/hurmishine/article/details/50198967 分析： 给出N头狼的攻击力和辅助攻击力，每头狼的攻击力等于它本身的攻击力加上它左右的狼的辅助攻击力，求出如何移走狼才能使得受到最小的攻击。 题解：区间D
dp：maximum sum，求数组不相交子区间的最大元素和
sophilex的博客
11-24 208
一个方法是，用两个dp数组来维护两个区间的最大元素和，为了保证不相交，我们可以让a【i】求以mas【i】为终点的最大区间和，b【i】求以mas【i】为起点的最大区间和，然后一次循环求出最大的a【i】并加上其下一个b【i】即可；
贪心算法：选择不相交区间
old_honest_man的博客
07-26 319
5927: 线段 分享至QQ空间 时间限制(普通/Java):6000MS/18000MS 内存限制:65536KByte 总提交: 67 测试通过:33 描述 在一个数轴上有n条线段，现选取其中k条线段使得这k条线段两两没有重合部分，问最大的k为多少? 输入 第一行为一个正整数n，下面n行每行2个数字ai，bi,描述每条线段。 对于20%的数据，n≤10。 对于50...
poj 2479/2593 两个不相交区间的最大子段和 dp
菜鸡的学习记录
03-27 316
2479 2593 这两题所要求的是一样 只是输入不太一样而已 思路： 其实这题算是求一个序列的最大子段和的一个拓展延伸 对于最大子段和 我们知道dp[i]=max(dp[i-1]+a[i],a[i]) 表示以i结尾的最大子段和 那么这题所要求的是要两个不相交的 所以我们考虑 开两个数组l,r 分别维护正序和倒序的最大子段和 处理完之后，注意我们要的是不相交即可 ，也就是第一个区间的右端点和第二个...
LeetCode-【差分解决区间问题】解题技巧
lanzh_
06-13 2083
1094. 拼车 此题关键在于：上车下车先后是固定的, 那么可以用差分法，在特定车站上车就+人数, 下车就-人数，那么计算, 如果出现 > capacity 就是false； 1.所有车站人数初始化为0； 2.遍历trips，依次维护上下车各车站人数变化； 3.遍历所有车站，累加各个车站人数，出现> > capacity 就是false，否则返回true; class Solution(object): def carPooling(self, trips, capac
分块算法 解决区间问题
m0_57006708的博客
09-30 159
块的操作主要有： block是块的大小 t是块的数量 st是每个块的开始的下标 ed是每个块的结束的下标 pos是每个元素对应块的下标 sum是对应块的元素的和 add是增量标记 用于区间修改+区间查询 核心代码如下： const int MAX=10010; int n; int a[MAX]; int st[MAX],ed[MAX]; int pos[MAX]; int sum[MAX]; int add[MAX]; //区间修改 void change(int l,in..
区间DP、概率DP与树形DP：小规模优化策略与实例解析
区间DP（Interval Dynamic Programming）是一种特殊类型的动态规划方法，它的核心思想是将问题分解为一系列互有关联的区间，每个区间的最优解是由更小区间合并而成的。例如，在HDOJ 9304 - 1000（Poj2955 Brackets）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值