Codeforces 487B. Strip(求区间最值＋线段树上的dp)

最新推荐文章于 2021-05-21 16:17:38 发布
最新推荐文章于 2021-05-21 16:17:38 发布
阅读量1.5k 收藏
点赞数
分类专栏： 算法设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peteryuanpan/article/details/41402053
版权

B. Strip
time limit per test
1 second
memory limit per test
256 megabytes
input
standard input
output
standard output

Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right.

Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it must satisfy:

  • Each piece should contain at least l numbers.
  • The difference between the maximal and the minimal number on the piece should be at most s.

Please help Alexandra to find the minimal number of pieces meeting the condition above.

Input

The first line contains three space-separated integers n, s, l (1 ≤ n ≤ 105, 0 ≤ s ≤ 109, 1 ≤ l ≤ 105).

The second line contains n integers ai separated by spaces ( - 109 ≤ ai ≤ 109).

Output

Output the minimal number of strip pieces.

If there are no ways to split the strip, output -1.

Sample test(s)
input 
7 2 2
1 3 1 2 4 1 2
output 
3
input 
7 2 2
1 100 1 100 1 100 1
output 
-1
Note

For the first sample, we can split the strip into 3 pieces: [1, 3, 1], [2, 4], [1, 2].

For the second sample, we can't let 1 and 100 be on the same piece, so no solution exists.


题意：将一个长度为n的数列划分成m个部分，要求每个部分含有的个数>=L，且每个部分最大值－最小值<=S，

求满足上述两个条件情况下m的最小值。即划分区间个数最小

题目地址：http://codeforces.com/contest/487/problem/B


为了形象地说明，举题目第一个栗子如下：


我们得到上列数列，A1－A7，长度为7

A1=1 , A2=3 , A3=1 , A4=2 , A5=4 , A6=1 , A7=2;

根据题目，每一个区间必须满足两个条件：条件一， 区间内元素个数>=L  ；  条件二， 区间最大值－最小值<=S

对于每个位置 i ，我们找到以 i 为左端点，往右拓展的区间，只考虑满足条件二时候，最远可到的位置是哪里。

A1=1，以1为左端点，我们可以得到7个区间

即 [A1,A1] : 1

     [A1,A2] : 1 3

     [A1,A3] : 1 3 1

     [A1,A4] : 1 3 1 2

     [A1,A5] : 1 3 1 2 4

     [A1,A6] : 1 3 1 2 4 1

     [A1,A7] : 1 3 1 2 4 1 2

我们容易得出每个区间最大值－最小值 的值，定义maxsubmin为每个区间最大值－最小值的值

则：

maxsubmin[A1,A1]=0

maxsubmin[A1,A2]=2

maxsubmin[A1,A3]=2

maxsubmin[A1,A4]=2

maxsubmin[A1,A5]=3

maxsubmin[A1,A6]=3

maxsubmin[A1,A7]=3

栗子一里S=2，意思是任意一个选取的区间maxsubmin值必须<=2

由此可知，从A1开始的区间中只有[A1,A1]，[A1,A2]，[A1,A3]，[A1,A4] 满足条件二

所以，从A1开始，往右拓展的区间，只考虑满足条件二的时候，最远可到达位置为 4


不妨定义 maxto[i] 表示从 i 开始，往右拓展的区间，只考虑条件二的时候，最远可到达的位置为 maxto[i]


对于原数列，我们很容易得出每个位置 i 的值 maxto[i]，如下图所示



我们得到了maxto[i]，表示的是从位置 i 开始，向右拓展，只考虑满足条件二时，最远可到达的位置为 maxto[i]

容易发现，假设此时要从位置 i 开始往右划分一段区间，根据条件一，区间元素个数必须>=L，也就是，从位置 i 开始，至少需要划到 i + L -1的位置

而当从位置 i 开始，即使划到位置n，区间元素个数也小于L的话，就不能从 i 开始往右划分。因为此时不满足条件一


我们很容易想到特判的条件，当n<L的时候，即数列个数小于L，无法满足条件一

同样地，从位置 i 开始，我已经知道只考虑条件二时最远可达位置 maxto[i]，此时如果maxto[i]－i＋1，也就是区间元素个数，小于L的话，就不能从 i 往右进行划分；



在以上的基础上，我们就可以动态规划地解决题目的问题

定义dp数组 dp[i]

dp[i] 表示 从1到 i－1这段区间上最小划分的区间个数

同样，以栗子一举例


我们已经知道，从A1开始的区间中只有[A1,A1]，[A1,A2]，[A1,A3]，[A1,A4] 满足条件二

但只有[A1,A2]，[A1,A3]，[A1,A4] 既满足条件二，又满足条件一

则，dp[3]=1，dp[4]=1，dp[5]=1

拿dp[3]举例，表示从1到2这段去区间上，划分的区间个数为1个，即[A1,A2]这一个区间


我们继续将这个步骤进行下去

如果我们从3处开始往右划分区间，根据之前得出的maxto[3]和题目给的L可以知道，只有[A3,A3]，[A3.A4]满足题意

所以dp[4]=min(dp[4],dp[3]+1)，dp[5]=min(dp[5],dp[3]+1)；

dp[3]+1=2，表示从1到2可以划分最小区间个数为1，从3到3 或 3到4，又可以进行一次划分，所以，从1到3 或 从1到4 可以进行两次划分

但是，我们从1到3 和 1到4 可以进行一次划分，所以根据题意，我们取更小的那次

dp[4]=min(dp[4],dp[3]+1)＝1，dp[5]=min(dp[5],dp[3]+1)＝1；

这个样子，动态规划的思想就很显然了

对于每个位置 i ，我们从之前的位置维护得到，从1到 i-1 这段区间最少可以划分成几个区间

那么，此时，我们再从 i 位置开始往右划分，再维护 i 位置右边的dp值。这样子answer=dp[n+1]，表示1到n区间最少可以划分成几个区间，就是我们要的答案


对于栗子一，我们可以得到一下dp数组：


其中INT表示正无穷，即2之前的区间[1,1]不能划分成区间（违背了条件一）

可以发现，answer=dp[8]=3，就是栗子一的答案


核心转移方程：dp[j]=min(dp[j]，dp[i]+1)；

初始化：dp[1]=0，dp[其他]＝无穷大(实际上，用1e9表示就够了)

而dp伪代码如下：

for(int i=1;i<=n;i++){
    dp[i]=无穷大;
}
dp[1]=0;

for(int i=1;i<=n;i++){
    if(从i开始到n这段区间元素个数<L) continue;
    if(dp[i]==无穷大) continue;
    int to=i+L-1;
    if(maxto[i]<to) continue;
    for(int j=to+1;j<=maxto[i]+1;j++){
        dp[j]=min(dp[j],dp[i]+1);
    }
}

但是！！

这么做是过不了这道题的＝。＝

用动态规划做没有问题，dp思想也是正确的，而问题出在复杂度上

可以发现上面伪代码的复杂度是：O(n^2)，n=10^5，很显然不可能1s解决问题


所以，这里就涉及到了标题所提到的，在线段树上进行dp

我们会发现上串为代码有这样一个for循环：

for(int j=to+1;j<=maxto[i]+1;j++){
        dp[j]=min(dp[j],dp[i]+1);
    }

这个for循环，实际上就是，将[to+1，maxto[i]+1]这段区间上dp值dp[j]与dp[i]+1取最小值。这是可以通过线段树懒操作来优化的

具体如何通过线段树来优化，我不愿意详述，相信熟悉线段树（需要用到懒操作）的朋友可以很容易写出来

如果不熟悉线段树的朋友，可以看我下面代码。不过建议多写线段树的懒操作，这样子才能有本质的提高。

线段树dp核心代码如下：

//线段树dp:
#define MAXN 100100
#define INT (0x3f3f3f3f)*2
struct Segment_Tree{
    int left,right;
    int dp,lazy;
}tree[4*MAXN];
void plant_tree(int id,int l,int r){
    tree[id].left=l,tree[id].right=r;
    tree[id].lazy=INT;
    if(l==r){
        if(l==1) tree[id].dp=0;
        else tree[id].dp=INT;
        return;
    }
    int mid=(l+r)>>1;
    plant_tree(id<<1,l,mid);
    plant_tree((id<<1)+1,mid+1,r);
    tree[id].dp=min(tree[id<<1].dp,tree[(id<<1)+1].dp);
}
void push_down(int id){//懒操作pushdown
    if(tree[id].lazy==INT) return;
    tree[id].dp=min(tree[id].dp,tree[id].lazy);
    if(tree[id].left==tree[id].right){
        tree[id].lazy=INT;
        return;
    }
    tree[id<<1].lazy=min(tree[id<<1].lazy,tree[id].lazy);
    tree[(id<<1)+1].lazy=min(tree[(id<<1)+1].lazy,tree[id].lazy);
    tree[id].lazy=INT;
}
void update_leaf(int id,int l,int r,int val){
    if(tree[id].left==l && tree[id].right==r){
        tree[id].lazy=min(tree[id].lazy,val);
        push_down(id);
        return;
    }
    push_down(id);
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) update_leaf(id<<1,l,r,val);
    else if(mid<l) update_leaf((id<<1)+1,l,r,val);
    else{
        update_leaf(id<<1,l,mid,val);
        update_leaf((id<<1)+1,mid+1,r,val);
    }
}
int query(int id,int l,int r){
    if(tree[id].left==l && tree[id].right==r){
        push_down(id);
        return tree[id].dp;
    }
    push_down(id);
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) return query(id<<1,l,r);
    else if(mid<l) return query((id<<1)+1,l,r);
    else return min(query(id<<1,l,mid),query((id<<1)+1,mid+1,r));
}


此题需要用到两棵线段树，一棵来查询a[i]任意区间上的最大最小值，另外一棵线段树就是用来动态规划解决问题

总代码如下：

//Hello. I'm Peter.
#include<cstdio>
#include<iostream>
#include<sstream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<functional>
#include<cctype>
#include<ctime>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
typedef long double ld;
#define peter cout<<"i am peter"<<endl
#define input freopen("data.txt","r",stdin)
#define randin srand((unsigned int)time(NULL))
#define INT (0x3f3f3f3f)*2
#define LL (0x3f3f3f3f3f3f3f3f)*2
#define gsize(a) (int)a.size()
#define len(a) (int)strlen(a)
#define slen(s) (int)s.length()
#define pb(a) push_back(a)
#define clr(a) memset(a,0,sizeof(a))
#define clr_minus1(a) memset(a,-1,sizeof(a))
#define clr_INT(a) memset(a,INT,sizeof(a))
#define clr_true(a) memset(a,true,sizeof(a))
#define clr_false(a) memset(a,false,sizeof(a))
#define clr_queue(q) while(!q.empty()) q.pop()
#define clr_stack(s) while(!s.empty()) s.pop()
#define rep(i, a, b) for (int i = a; i < b; i++)
#define dep(i, a, b) for (int i = a; i > b; i--)
#define repin(i, a, b) for (int i = a; i <= b; i++)
#define depin(i, a, b) for (int i = a; i >= b; i--)
#define pi 3.1415926535898
#define eps 1e-6
#define MOD 1000000007
#define MAXN 100100
#define N
#define M
//线段树求最值
struct Segment_TreeforRMQ{
    int left,right;
    int min,max;
}treeRMQ[4*MAXN];
void plant_treeforRMQ(int id,int l,int r,Segment_TreeforRMQ* tree,int *a){
    tree[id].left=l,tree[id].right=r;
    if(l==r){
        tree[id].min=tree[id].max=a[l];
        return;
    }
    int mid=(l+r)>>1;
    plant_treeforRMQ(id<<1,l,mid,tree,a);
    plant_treeforRMQ((id<<1)+1,mid+1,r,tree,a);
    tree[id].min=min(tree[id<<1].min,tree[(id<<1)+1].min);
    tree[id].max=max(tree[id<<1].max,tree[(id<<1)+1].max);
}
int query_min(int id,int l,int r,Segment_TreeforRMQ* tree){
    if(tree[id].left==l && tree[id].right==r){
        return tree[id].min;
    }
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) return query_min(id<<1,l,r,tree);
    else if(mid<l) return query_min((id<<1)+1,l,r,tree);
    else return min(query_min(id<<1,l,mid,tree),query_min((id<<1)+1,mid+1,r,tree));
}
int query_max(int id,int l,int r,Segment_TreeforRMQ* tree){
    if(tree[id].left==l && tree[id].right==r){
        return tree[id].max;
    }
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) return query_max(id<<1,l,r,tree);
    else if(mid<l) return query_max((id<<1)+1,l,r,tree);
    else return max(query_max(id<<1,l,mid,tree),query_max((id<<1)+1,mid+1,r,tree));
}
//查询最大值-最小值
int maxsubmin(int from,int to){
    return query_max(1,from,to,treeRMQ)-query_min(1,from,to,treeRMQ);
}
//线段树dp:
struct Segment_Tree{
    int left,right;
    int dp,lazy;
}tree[4*MAXN];
void plant_tree(int id,int l,int r){
    tree[id].left=l,tree[id].right=r;
    tree[id].lazy=INT;
    if(l==r){
        if(l==1) tree[id].dp=0;
        else tree[id].dp=INT;
        return;
    }
    int mid=(l+r)>>1;
    plant_tree(id<<1,l,mid);
    plant_tree((id<<1)+1,mid+1,r);
    tree[id].dp=min(tree[id<<1].dp,tree[(id<<1)+1].dp);
}
void push_down(int id){//懒操作pushdown
    if(tree[id].lazy==INT) return;
    tree[id].dp=min(tree[id].dp,tree[id].lazy);
    if(tree[id].left==tree[id].right){
        tree[id].lazy=INT;
        return;
    }
    tree[id<<1].lazy=min(tree[id<<1].lazy,tree[id].lazy);
    tree[(id<<1)+1].lazy=min(tree[(id<<1)+1].lazy,tree[id].lazy);
    tree[id].lazy=INT;
}
void update_leaf(int id,int l,int r,int val){
    if(tree[id].left==l && tree[id].right==r){
        tree[id].lazy=min(tree[id].lazy,val);
        push_down(id);
        return;
    }
    push_down(id);
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) update_leaf(id<<1,l,r,val);
    else if(mid<l) update_leaf((id<<1)+1,l,r,val);
    else{
        update_leaf(id<<1,l,mid,val);
        update_leaf((id<<1)+1,mid+1,r,val);
    }
}
int query(int id,int l,int r){
    if(tree[id].left==l && tree[id].right==r){
        push_down(id);
        return tree[id].dp;
    }
    push_down(id);
    int mid=(tree[id].left+tree[id].right)>>1;
    if(r<=mid) return query(id<<1,l,r);
    else if(mid<l) return query((id<<1)+1,l,r);
    else return min(query(id<<1,l,mid),query((id<<1)+1,mid+1,r));
}
void printno(){
    printf("%d\n",-1);
    exit(0);
}
int n,s,l;
int a[MAXN],maxto[MAXN];
int main()
{
    cin>>n>>s>>l;
    repin(i,1,n){
        scanf("%d",a+i);
    }
    if(n<l) printno();//当n<l的时候，不成立
    plant_treeforRMQ(1,1,n,treeRMQ,a);//建立树，为了求a数组的最值
    int to=1;
    repin(i,1,n){//求出只满足maxi-mini<=s的条件下，每个点i最远可往右到哪个点
        to=max(to,i);
        while(1){
            if(to==n){
                maxto[i]=to;
                break;
            }
            int t=maxsubmin(i,to+1);
            if(t<=s) to+=1;
            else{
                maxto[i]=to;
                break;
            }
        }
    }
    plant_tree(1,1,n+1);//线段树dp，建树
    repin(i,1,n){//dp，用线段树优化
        if(n-i+1<l) continue;
        int now=query(1,i,i);
        if(now==INT) continue;
        int to=i+l-1;
        if(maxto[i]<to) continue;
        update_leaf(1,to+1,maxto[i]+1,now+1);
    }
    int ans=query(1,n+1,n+1);
    if(ans==INT) ans=-1;
    printf("%d\n",ans);
}


ACM-算法之道
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CF487B Strip（RMQ）（DP）
ezoi_ly的博客
10-03 226
直接RMQ即可，最后套一个简单DP。 RMQ求出区间的元素的最大值和最小值。 后面直接一遍DP。 dp[i]表示前i个数最少要分成多少份。 满足条件时： dp[i]=min(dp[i],dp[ok]+1)dp[i]=min(dp[i],dp[ok]+1)dp[i]=min(dp[i],dp[ok]+1) #include<bits/stdc++.h> #define inf 21474...
codeforces 487B B. Strip(rmq+线段树+二分)
llin-黎辰
10-05 1598
题目链接：codeforces 487B题目大意：给出一个序列，要把序列划分成段，每一段最少有L个元素，段中的最大元素和最小元素之差不大于s，问划分的段的最少的数量是多少。题目分析： 首先用rmq维护区间最大值和区间最小值。 然后按顺序扫描数组，线段树维护的数组，每个记录当前点作为最后一个点的前i个点划分的最小的段数，那么每次更新就是二分找到可以转移到我的最远距离，然后再选取与我距离大于l的那部分，
codeforces 487 B. Strip
Every day
02-09 458
题意：一个数列分成若干段，满足两个条件，1.每一段长度l>=s，2.每一段mx-mi 分析：一个很常见的思路，先预处理每个数最左边可行位置pre[i]，动态方程，dp[i]=min(dp[k]+1)，pre[i]-1#include #include #include #include #include #include #include #include #include #include #
CodeForces - 487B Strip(线段树+dp+二分)
Falcon的博客
11-25 207
题目链接：点击查看 题目大意：给出一个长度为 n 的序列，现在要求分成尽可能少的子段，且每个子段需要满足： 最大值与最小值的差值小于等于 s 子段长度大于等于 l 题目分析：dp[ i ] 代表的是前 i 个数字分成最少的子段个数，转移方程如下： dp[ i ] = dp[ j - 1 ] + 1：第 i 项单独一段 dp[ i ] = dp[ j - 2 ] + 1：第 i 项与 i - 1 项组成一段 ... dp[ i ] = dp[ 0 ] + 1：第 1 ~ i 项组成一段 显然是取
CodeForces - 834D(线段树优化dp)
XFire的博客
06-21 502
给你长度为N的一个序列，让你将其分成连续的k段，每段的价值为其中数字种类的个数，求最大价值总和。   首先能想到n^2复杂度的dp 设定dp[i][j]表示到位子i,分成j段的最大价值总和。 dp[i][j]=max( dp[i][j]，dp[k][j-1]+val(k+1,i) )；k为这个数上一次出现的位置 可以用线段树加速转移。 考虑val(k+1,j). 我们遍历到第j个位子...
Codeforces.264E.Roadside Trees(线段树 DP LIS)
weixin_30751947的博客
10-04 111
题目链接 \(Description\) \(Solution\) 还是看代码好理解吧。 为了方便，我们将x坐标左右反转，再将所有高度取反，这样依然是维护从左到右的LIS，但是每次是在右边删除元素。 这样对于在p刚种的树，最多只有9棵树比它高，即它只会转移到这9棵树，除这9棵树外，它可以从1~p-1的任何树转移（其它9棵树除比它高的外 同样可以从它前面任何树转移）。 我们把这9棵树的DP值暴力删...
CodeForces - 1527E Partition Game(dp+线段树)
Falcon的博客
05-21 559
题目链接：点击查看 题目大意：给出一个长度为 nnn 的数列，现在需要将其划分成 kkk 段，使得贡献和最小 对于每段区间 [l,r][l,r][l,r] 的贡献为，其中每个数字，其最后一次出现的位置减去其首次出现的位置 输出最小贡献 题目分析：区间划分，经典的 dpdpdp 问题，dpi,jdp_{i,j}dpi,j​ 代表前 iii 个数划分为 jjj 个区间的最优解，两种转移方程： dpi,j=min(dpi−1,j+(ai属于上一段的贡献),dpi−1,j−1+(ai独成一段的贡献))dp_{i,
codeforces 487B Strip
Elijahqi
05-17 353
http://www.elijahqi.win/archives/1355 Alexandra has a paper strip with n numbers on it. Let’s call them ai from left to right. Now Alexandra wants to split it into some pieces (possibly 1). For each...
Codeforces 487B Strip(RMQ)
不慌不忙、不急不躁
03-19 1257
题目链接：Codeforces 487B Strip #include #include #include #include #include using namespace std; const int maxn = 1e5 + 5; const int maxr = 20; const int inf = 0x3f3f3f3f; int ca, cd, AS[maxn],
Codeforces 487B. Strip DP+线段树+二分
码代码的猿猿
03-12 1103
dp[ i ]表示到第i个位置最少要分多少下, dp[ i ] = min ( dp [ i ] , dp [ j ] + 1 ) j 在合适的范围内 (  满足长度和最值差 ) 对整个数组建立线段树维护最大值和最小值这样就可在nlogn的时间里求出某一段的最值差,这个范围是满足单调性的,所以对于每个i可以二分出j的最小值 .  对每个dp[i]建立线段树,可以在nlogn时间内求出最
【DP】 codeforces 487B Strip
yysys
11-24 730
单调队列优化DP。。。 #include #include #include #include #include #include #include #include #include #include #include #include #include #define maxn 1000005 #define maxm 2000005 #define
【Monotonic-queue】【dp】【Segment-tree】【STL】Codeforces 487B - Strip
qq_20535099的博客
03-06 688
Describtion： Alexandra has a paper strip with n numbers on it. Let's call them ai from left to right. Now Alexandra wants to split it into some pieces (possibly 1). For each piece of strip, it
Codeforces 750E 线段树DP
weixin_30546933的博客
09-08 131
题意：给你一个字符串，有两种操作：1：把某个位置的字符改变。2：询问l到r的子串最少需要删除多少个字符，使得这个子串含有2017子序列，并且没有2016子序列？ 思路：线段树上DP，我们设状态0, 1, 2, 3, 4分别为: null, 2, 20, 201, 2017的最小花费，我们用线段树来维互状态转移的花费矩阵，合并相邻的两个子串的时候直接转移即可。 代码： #incl...
Codeforces 487b Strip, dp + RMQ（经典）
Mathon
09-06 509
题意：有一个长度为n的数列，问是否能把这个数列切成连续的几段，使得 1.每一段长度大于等于l；2.每一段中的最大值和最小值之差小于等于s。如果能输出能切成的最小的段数，不能输出-1。 思路：非常经典的dp题目，假设dp[i]表示a1...aia_1...a_i这个序列能切成的最小段数，如果不能dp[i] = INF。现在问题是 1.如何找到状态转移方程。考虑如果l = 3， s = 1，如果ai
HDU 1827 Summer Holiday 求每一个连通块内点的权值最小
猫ER
05-05 478
题意：听说lcy帮大家预定了新马泰7日游，Wiskey真是高兴的夜不能寐啊，他想着得快点把这消息告诉大家，虽然他手上有所有人的联系方式，但是一个一个联系过去实在太耗时间和电话费了。他知道其他人也有一些别人的联系方式，这样他可以通知其他人，再让其他人帮忙通知一下别人。你能帮Wiskey计算出至少要通知多少人，至少得花多少电话费就能让所有人都被通知到吗？ 想法：只要在提取一个连通块每一个点的
CF487B Strip（单调队列预处理+单调队列优化dp）
Icefox的博客
10-19 573
这题妙啊。。。堪称优先队列中的典范了啊。。。 首先预处理出L数组，表示右边界为i,左边界最多能扩展到L[i] 。这个过程可以通过两个单调队列和一个指针p解决，分别维护区间最大最小值即可。复杂度O(n) 然后进行dp,dp[i]表示前i个数至少分成几部分，不能分的为inf，考虑转移： dp[i]=min{dp[j]| L[i]-1<=j<=i-l}+1，然而朴素转移是O(n^2)的，显然会T。而
codeforces 区间dp
最新发布
10-04
在Codeforces竞赛中，区间DP经常被用于解决一些复杂的字符串或序列相关的问题。 在区间DP中，dp[i][j]表示第一个序列前i个元素和第二个序列前j个元素的最优解。具体的转移方程会根据具体的问题而变化，但是通常会...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值