区间DP专题

最新推荐文章于 2021-02-08 16:53:32 发布
最新推荐文章于 2021-02-08 16:53:32 发布
阅读量158 收藏
点赞数
分类专栏： 训练集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43874261/article/details/102635111
版权

LIGHTOJ1422

这个题可以从两种角度来考虑，第一种是根据题意中的套衣服设定，如果出现一件衣服是之前穿过的，那么枚举讨论新的同款衣服需不需要额外穿一次。第二种是根据刷区间设定（HDU2476），如果现在出现了一个之前出现过的的颜色，那么讨论这个颜色是否可以从之前直接刷过来。（实际上两种设定一样）

那么根据设定可以确定这样的状态转移：对于任意一件衣服，如果在此之前的区间（这个区间为i->j）出现了一件和当前相同的衣服，那么讨论是否需要利用之前的衣服，还是新穿上这样的衣服。

即dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j-1])（默认新区间是从右侧扩张的，j-1是扩张之前的区间右端点）。

当然，对于每个长度为1的区间，也就是单个元素时，根据题目设定，容易知道dp[i][i]=1

//#include<pch.h>
#include <iostream>
#include <cstdio>
#include <bits/stdc++.h>
#include <queue>
#include <map>
#include <algorithm>
#include <stack>
#include <iomanip>
#include <cstring>
#include <cmath>
//#define endl '\n'
#define DETERMINATION main
#define For(a,b,c,d) for(int a=b;a<=c;a+=d)
#pragma GCC optimize(2)
#pragma warning(disable:4996)
#define lldin(a) scanf("%lld", &a)
#define println(a) printf("%lld\n", a)
#define print(a) printf("%lld ", a)
#define reset(a, b) memset(a, b, sizeof(a))
#define debug std::cout<<"procedures above are available"<<"\n";
#define BigInteger __int128
using namespace std;
const long long INF = 2147483647;
const double PI = acos(-1);
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int mod = 1e9 + 7;
//template<typename T>
//inline BigInteger nextBigInteger()
//{
//    BigInteger tmp = 0, si = 1;char c;    c = getchar();
//    while (!isdigit(c))
//{if (c == '-')si = -1;c = getchar();}
//    while (isdigit(c))
//    {tmp = tmp * 10 + c - '0';c = getchar();}
//    return si * tmp;
//}
//std::ostream& operator<<(std::ostream& os, __int128 T)
//{
//    if (T<0) os<<"-";if (T>=10 ) os<<T/10;if (T<=-10) os<<(-(T/10));
//    return os<<( (int) (T%10) >0 ? (int) (T%10) : -(int) (T%10) ) ;
//}
//void output(BigInteger x)
//{
//    if (x < 0)
//    {x = -x;putchar('-');}
//    if (x > 9) output(x / 10);
//    putchar(x % 10 + '0');
//    }
/**Operation Overlord 1944.6.6 Daybreak**/
/**Last Remote**/
ll arr[500];
ll dp[210][210];
int DETERMINATION()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(0),std::cout.tie(0);
	ll t;
	cin>>t;
	for(int y=1;y<=t;y++)
	{
        ll n;
        cin>>n;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                dp[i][j]=0;
        for(int i=1;i<=n;i++)
            cin>>arr[i];
        for(int i=1;i<=n;i++)
            dp[i][i]=1;
        //cout<<dp[1][1]<<endl;
        for(int len=2;len<=n;len++)
        {
            for(int i=1;i+len-1<=n;i++)
            {
                int j=i+len-1;
                dp[i][j]=dp[i][j-1]+1;
                for(int k=i;k<=j-1;k++)
                {
                    if(arr[k]==arr[j])
                        dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j-1]);
                }
            }
        }
        cout<<"Case "<<y<<": "<<dp[1][n]<<endl;
	}
	return 0;
}

POJ2955

本题是一个关于括号序列的题目，这里要求的是最长合法括号子序列，所以并不能用栈来解决问题。因为是一个关于区间最优解的问题，所以选择使用区间DP。

对于本题而言，它的区间是从两端发散，由小扩展到大的，而扩展的条件是区间两端存在一对合法括号。扩展之后再划分区间即可，此时这个划分区间的用意是由两个子区间拼接形成新的区间。

//#include<pch.h>
#include <iostream>
#include <cstdio>
//#include <bits/stdc++.h>
#include <queue>
#include <map>
#include <algorithm>
#include <stack>
#include <iomanip>
#include <cstring>
#include <cmath>
//#define endl '\n'
#define DETERMINATION main
#define For(a,b,c,d) for(int a=b;a<=c;a+=d)
#pragma GCC optimize(2)
#pragma warning(disable:4996)
#define lldin(a) scanf("%lld", &a)
#define println(a) printf("%lld\n", a)
#define print(a) printf("%lld ", a)
#define reset(a, b) memset(a, b, sizeof(a))
#define debug std::cout<<"procedures above are available"<<"\n";
#define BigInteger __int128
using namespace std;
const long long INF = 2147483647;
const double PI = acos(-1);
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int mod = 1e9 + 7;
//template<typename T>
//inline BigInteger nextBigInteger()
//{
//    BigInteger tmp = 0, si = 1;char c;    c = getchar();
//    while (!isdigit(c))
//{if (c == '-')si = -1;c = getchar();}
//    while (isdigit(c))
//    {tmp = tmp * 10 + c - '0';c = getchar();}
//    return si * tmp;
//}
//std::ostream& operator<<(std::ostream& os, __int128 T)
//{
//    if (T<0) os<<"-";if (T>=10 ) os<<T/10;if (T<=-10) os<<(-(T/10));
//    return os<<( (int) (T%10) >0 ? (int) (T%10) : -(int) (T%10) ) ;
//}
//void output(BigInteger x)
//{
//    if (x < 0)
//    {x = -x;putchar('-');}
//    if (x > 9) output(x / 10);
//    putchar(x % 10 + '0');
//    }
/**Operation Overlord 1944.6.6 Daybreak**/
/**Last Remote**/
char arr[5000];
ll dp[120][120];
int DETERMINATION()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(0), std::cout.tie(0);
	while (cin >> (arr + 1))
	{
		if (arr[1] == 'e')
			break;
		reset(dp, 0);
		ll n = strlen(arr + 1);
		for (int len = 2; len <= n; len++)
		{
			for (int i =1; i + len - 1 <= n; i++)
			{
				ll j = i + len - 1;
				if ((arr[i] == '['&&arr[j] == ']') || (arr[i] == '('&&arr[j] == ')'))
					dp[i][j] = dp[i + 1][j - 1] + 2;
				for (int k = i; k <= j - 1; k++)
					dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j]);
			}
		}
		cout << dp[1][n] << endl;
	}
	//cout << power[0] << endl;
	return 0;
}

CF149D

本题分三种情况：

第一种是    ()，这是最底层的情况，只需要将合法的dp[l][r][i][j]赋值为1即可。

第二种是    (......),这可以看做是由多组第一种情况在两边加上一对括号扩展而来的，在扩展中注意判断相邻的括号不能相同颜色即可。也就是dp[l][r][m][n]+=dp[l+1][r-1][i][j]。

第三种是(......)(......)这个时候就需要利用区间DP分割区间了，不过枚举非常耗时间，鉴于题目中给定的是一个正确的括号序列（两两配对），所以可以直接用一个栈把每个左括号对应的右括号记录下来，然后在这里就很容易找出区间分隔点。

即dp[l][r][i][j]=dp[i][correspond(i)][i][j]*dp[correspond(i)+1][r][i][j]。由于括号必定是两两配对的，所以correspond（i+1）必然是与correspond（i）相邻且方向相异的，因为如果方向相同的话在区间左侧就再没有括号与之配对了。

本题难以从底部问题来推导最终问题，所以采用记忆化搜索自上而下，再回溯计算答案。

//#include<pch.h>
#include <iostream>
#include <cstdio>
#include <bits/stdc++.h>
#include <queue>
#include <map>
#include <algorithm>
#include <stack>
#include <iomanip>
#include <cstring>
#include <cmath>
//#define endl '\n'
#define DETERMINATION main
#define For(a,b,c,d) for(int a=b;a<=c;a+=d)
#pragma GCC optimize(2)
#pragma warning(disable:4996)
#define lldin(a) scanf("%lld", &a)
#define println(a) printf("%lld\n", a)
#define print(a) printf("%lld ", a)
#define reset(a, b) memset(a, b, sizeof(a))
#define debug std::cout<<"procedures above are available"<<"\n";
#define BigInteger __int128
using namespace std;
const long long INF = 2147483647;
const double PI = acos(-1);
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int mod = 1e9 + 7;
//template<typename T>
//inline BigInteger nextBigInteger()
//{
//    BigInteger tmp = 0, si = 1;char c;    c = getchar();
//    while (!isdigit(c))
//{if (c == '-')si = -1;c = getchar();}
//    while (isdigit(c))
//    {tmp = tmp * 10 + c - '0';c = getchar();}
//    return si * tmp;
//}
//std::ostream& operator<<(std::ostream& os, __int128 T)
//{
//    if (T<0) os<<"-";if (T>=10 ) os<<T/10;if (T<=-10) os<<(-(T/10));
//    return os<<( (int) (T%10) >0 ? (int) (T%10) : -(int) (T%10) ) ;
//}
//void output(BigInteger x)
//{
//    if (x < 0)
//    {x = -x;putchar('-');}
//    if (x > 9) output(x / 10);
//    putchar(x % 10 + '0');
//    }
/**Operation Overlord 1944.6.6 Daybreak**/
/**Last Remote**/
char arr[780];
ll dp[800][800][3][3];
ll correspond[870];
stack<ll>stk;
void dfs(ll CL, ll CU)
{
	if (CL + 1 == CU)
		dp[CL][CU][0][1] = dp[CL][CU][0][2] = dp[CL][CU][1][0] = dp[CL][CU][2][0] = 1;
	else if (correspond[CL] == CU)
	{
		dfs(CL + 1, CU - 1);
		for (int i = 0; i <= 2; i++)
		{
			for (int j = 0; j <= 2; j++)
			{
				if (j != 1)
					dp[CL][CU][0][1] = (dp[CL][CU][0][1] + dp[CL + 1][CU - 1][i][j]) % mod;
				if (j != 2)
					dp[CL][CU][0][2] = (dp[CL][CU][0][2] + dp[CL + 1][CU - 1][i][j]) % mod;
				if (i != 1)
					dp[CL][CU][1][0] = (dp[CL][CU][1][0] + dp[CL + 1][CU - 1][i][j]) % mod;
				if (i != 2)
					dp[CL][CU][2][0] = (dp[CL][CU][2][0] + dp[CL + 1][CU - 1][i][j]) % mod;
			}
		}
	}
	else
	{
		dfs(CL, correspond[CL]);
		dfs(correspond[CL] + 1, CU);
		for (int i = 0; i <= 2; i++)
		{
			for (int j = 0; j <= 2; j++)
			{
				for (int k = 0; k <= 2; k++)
				{
					for (int m = 0; m <= 2; m++)
					{
						if ((j == 1 && k == 1) || (j == 2 && k == 2))
							continue;
						dp[CL][CU][i][m] = (dp[CL][CU][i][m] + dp[CL][correspond[CL]][i][j]%mod* dp[correspond[CL] + 1][CU][k][m]%mod)%mod;
					}
				}
			}
		}
	}
}
int DETERMINATION()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(0), std::cout.tie(0);
	cin >> arr + 1;
	ll len = strlen(arr + 1);
	for (int i = 1; i<=len; i++)
	{
		if (arr[i] == '(')
			stk.push(i);
		else
		{
			correspond[stk.top()] = i;
			correspond[i] = stk.top();
			stk.pop();
		}
	}
	dfs(1, len);
	ll ans = 0;
	for (int i = 0; i <= 2; i++)
	{
		for (int j = 0; j <= 2; j++)
		{
			ans = (ans + dp[1][len][i][j]) % mod;
			//cout << dp[1][len][i][j] << endl;
		}
	}
	cout << ans << endl;
	return 0;
}

 POJ1651

本题的主要难点在于DP数组上。如果仍然把dp[l][r]认为是[l,r]一整个连续区间内的值中，取一个数的最大值，那就很难做出这道题。所以可以换个思路，认为dp[l][r]为区间内两边只剩下l，r和某个数的最大乘积。

那么这个题的状态转移方程就可以认定为：dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]+a[i]*a[j]*a[k])，其中dp[i][k],dp[k+1][j]就是两个在之前的循环中已经解决的子问题，可以直接调用结果。（注意两个子区间都必须包括K）

//#include<pch.h>
#include <iostream>
#include <cstdio>
//#include <bits/stdc++.h>
#include <queue>
#include <map>
#include <algorithm>
#include <stack>
#include <iomanip>
#include <cstring>
#include <cmath>
//#define endl '\n'
#define DETERMINATION main
#define For(a,b,c,d) for(int a=b;a<=c;a+=d)
#pragma GCC optimize(2)
#pragma warning(disable:4996)
#define lldin(a) scanf("%lld", &a)
#define println(a) printf("%lld\n", a)
#define print(a) printf("%lld ", a)
#define reset(a, b) memset(a, b, sizeof(a))
#define debug std::cout<<"procedures above are available"<<"\n";
#define BigInteger __int128
using namespace std;
const long long INF = 2147483647;
const double PI = acos(-1);
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int mod = 1e9 + 7;
//template<typename T>
//inline BigInteger nextBigInteger()
//{
//    BigInteger tmp = 0, si = 1;char c;    c = getchar();
//    while (!isdigit(c))
//{if (c == '-')si = -1;c = getchar();}
//    while (isdigit(c))
//    {tmp = tmp * 10 + c - '0';c = getchar();}
//    return si * tmp;
//}
//std::ostream& operator<<(std::ostream& os, __int128 T)
//{
//    if (T<0) os<<"-";if (T>=10 ) os<<T/10;if (T<=-10) os<<(-(T/10));
//    return os<<( (int) (T%10) >0 ? (int) (T%10) : -(int) (T%10) ) ;
//}
//void output(BigInteger x)
//{
//    if (x < 0)
//    {x = -x;putchar('-');}
//    if (x > 9) output(x / 10);
//    putchar(x % 10 + '0');
//    }
/**Operation Overlord 1944.6.6 Daybreak**/
/**Last Remote**/
ll dp[120][120];
ll arr[1200];
int DETERMINATION()
{
	std::ios::sync_with_stdio(false);
	std::cin.tie(0), std::cout.tie(0);
	ll n;
	cin >> n;
	for (int i = 1; i <= n; i++)
		cin >> arr[i];
	for (int i = 1; i < n; i++)
		dp[i][i + 1] = 0;
	for (int len = 2; len <=n; len++)
	{
		for (int i = 1; len + i<=n; i++)
		{
			ll j = len + i;
			for (int k = i + 1; k <= j -1; k++)
			{
				if (dp[i][j] != 0)
					dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] + arr[k] * arr[i] * arr[j]);
				else
					dp[i][j] = dp[i][k] + dp[k][j] + arr[k] * arr[i] * arr[j];
			}
		}
	}
	cout << dp[1][n] << endl;
	return 0;
}

HDU4283

本题需要用特殊的区间dp来解决。

所谓特殊主要是特殊在区间合并上，这里需要假定第i个人第K个上场，这就演化出了两个子问题dp[i+1][k],dp[k+1][j]，在这两个的子问题的基础上还需要加上当前人的愤怒值和在他之后上场的人的愤怒值。

从初始化的角度来说，当每个子区间只有一个人的时候，愤怒值自然为0，其余的设定为inf，但是在这里k+1可能会越界，所以还需要加一个必要的边界保护。

//#include<pch.h>
#include <iostream>
#include <cstdio>
#include <bits/stdc++.h>
#include <queue>
#include <map>
#include <algorithm>
#include <stack>
#include <iomanip>
#include <cstring>
#include <cmath>
//#define endl '\n'
#define DETERMINATION main
#define For(a,b,c,d) for(int a=b;a<=c;a+=d)
#pragma GCC optimize(2)
#pragma warning(disable:4996)
#define lldin(a) scanf("%lld", &a)
#define println(a) printf("%lld\n", a)
#define print(a) printf("%lld ", a)
#define reset(a, b) memset(a, b, sizeof(a))
#define debug std::cout<<"procedures above are available"<<"\n";
#define BigInteger __int128
using namespace std;
const long long INF = 2147483647;
const double PI = acos(-1);
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int mod = 1e9 + 7;
//template<typename T>
//inline BigInteger nextBigInteger()
//{
//    BigInteger tmp = 0, si = 1;char c;    c = getchar();
//    while (!isdigit(c))
//{if (c == '-')si = -1;c = getchar();}
//    while (isdigit(c))
//    {tmp = tmp * 10 + c - '0';c = getchar();}
//    return si * tmp;
//}
//std::ostream& operator<<(std::ostream& os, __int128 T)
//{
//    if (T<0) os<<"-";if (T>=10 ) os<<T/10;if (T<=-10) os<<(-(T/10));
//    return os<<( (int) (T%10) >0 ? (int) (T%10) : -(int) (T%10) ) ;
//}
//void output(BigInteger x)
//{
//    if (x < 0)
//    {x = -x;putchar('-');}
//    if (x > 9) output(x / 10);
//    putchar(x % 10 + '0');
//    }
/**Operation Overlord 1944.6.6 Daybreak**/
/**Last Remote**/
ll dp[200][200];
ll arr[230];
ll sum[230];
int DETERMINATION()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0), std::cout.tie(0);
    ll t;
    cin >> t;
    for (int y = 1; y <= t; y++)
    {
        ll n;
        cin >> n;
        reset(sum, 0);
        for (int i = 1; i <= n; i++)
        {
            cin >> arr[i];
            sum[i] = sum[i - 1] + arr[i];
        }
        reset(dp, 0x3f);
        for (int i = 1; i <= n; i++)
            dp[i][i] = 0;
        for (int l = 1; l < n; l++)
        {
            for (int i = 1; i + l <= n; i++)
            {
                ll j = i + l;
                for (int k = i; k <=j; k++)
                    dp[i][j] = min(dp[i][j], (k - i)*arr[i] + (k - i+1)*(sum[j] - sum[k]) + dp[min(i + 1,k)][k] + dp[min(k + 1,(int)j)][j]);
            }
        }
        cout << "Case #" << y << ": " << dp[1][n] << endl;
    }
    return 0;
}

 

西行妖下的亡灵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mythsman#blog-source#区间dp专题小结1
07-25
区间DP是一类在区间上进行动态规划的最优问题，一般是根据问题设出一个表示状态的dp，可以是二维的也可以是三维的，一般情况下为二维。然后将问题划分成两个子问题，也
区间DP 的两种解法
v5browser
07-01 128
POJ 2955 为例。 1 for循环 /* 经典的区间DP模型--最大括号匹配数。 如果找到一对匹配的括号[xxx]oooo，就把区间分成两部分，一部分是xxx，一部分是ooo，然后以此递归直到区间长度为1或者为2. */ #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;cstring&gt; #incl...
LeetCode 312. 戳气球
weixin_38199770的博客
02-08 79
//解法一：dp 左开右开区间写法 class Solution { public int maxCoins(int[] nums) { int n = nums.length; int[] arr = new int[n + 2]; arr[0] = arr[n + 1] = 1; for(int i = 1; i <= n; i++) arr[i] = nums[i - 1]; int.
【专题】区间dp
Lesroad
10-05 206
1.【nyoj737】石子合并传送门：点击打开链接描述    有N堆石子排成一排，每堆石子有一定的数量。现要将N堆石子并成为一堆。合并的过程只能每次将相邻的两堆石子堆成一堆，每次合并花费的代价为这两堆石子的和，经过N-1次合并后成为一堆。求出总的代价最小值。输入有多组测试数据，输入到文件结束。每组测试数据第一行有一个整数n，表示有n堆石子。接下来的一行有n（0&lt; n &lt;200）个数，分...
动态规划之区间DP专题
剑锋OI SharpSwordOI
12-14 1029
动态规划之区间DP专题 什么是区间DP 所谓区间dp,就是在一个区间上进行的dp， 一般通过将大区间分割成小区间进行dp。 区间型动态规划，又称为合并类动态规划，是线性动态规划的扩展，它在分阶段地划分问题时，与阶段中元素出现的顺序和由前一阶段的区间中哪些元素合并而来有很大的关系。 区间动归状态转移方程及一般动规过程： for k:=1 to n-1 do //区间长度 ...
DP(区间专题八)
weixin_43533544的博客
08-11 129
题意: 题意还是很复杂的, 还是看题面理解的快些 >> [IOI1998]Polygon << Strategy:环链化 + 区间dp 其实这一题和石子合并挺像的 状态: dp[l][r]→dp[l][r]\todp[l][r]→该区间内最大收益 目标:max⁡(dp[i∈[1,n]][n+i−1])\max(dp[i\in[1,n]][n + i - 1])max(dp[...
acm的DP专题
06-11
acm的DP专题，以供新手使用，希望跟大家一起进步和学习
3区间DP1
08-08
1. 基本区间DP#include <bits/stdc++.h>using namespace std;
区间DP概率DP树形DP插头DP
09-05
区间DP概率DP树形DP插头DP，每种DP一道典型例题，有助于初学者
dp专题1
08-03
dp专题1
区间dp专题
weixin_30690833的博客
08-12 54
HDU4283You Are the One区间dp， 记忆话搜索运行时间： #include <iostream> #include <cstdio> #include <cstring> using namespace std; const int maxn = 105,inf = 1<<30; int dp[max...
chromedriver-linux64-V124.0.6367.91 稳定版
04-30
chromedriver-linux64-V124.0.6367.91稳定版
基于yolov7 加入 depth回归
04-30
在官方的基础上改了检测头、导出onnx（适配tensorrt pro 项目）、测试demo等代码。 能够使用清华V2X数据集进行训练和测试。 https://www.bilibili.com/video/BV1Wd4y1G78M/?vd_source=0223c707743ff3013adaeff54aee3506 数据集来源：https://thudair.baai.ac.cn/index 基于Yolov7 tiny，加入了距离回归 模型没收敛完，随便试了下，所以预测有抖动 使用TRT加速，在AGX Xavier上推理大约4ms V2X使用tools/convertlabel2yolo.ipynb 进行数据集转换
基于STM32F101单片机设计Bluetooth Sentinel 主板硬件（原理图+PCB）工程文件.zip
04-30
基于STM32F101单片机设计Bluetooth Sentinel 主板硬件（原理图+PCB）工程文件，仅供学习设计参考。
【前端热门框架【vue框架】】——条件渲染和列表渲染的学习的秒杀方式 (2).txt
04-30
【前端热门框架【vue框架】】——条件渲染和列表渲染的学习的秒杀方式 (2)
liba2ps1-4.14-bp155.4.9.aarch64.rpm
04-30
liba2ps1-4.14-bp155.4.9.aarch64
111111111111111111
最新发布
04-30
1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
codeforces 区间dp
10-04
区间DP是一种动态规划的方法，用于解决区间范围内的问题。在Codeforces竞赛中，区间DP经常被用于解决一些复杂的字符串或序列相关的问题。 在区间DP中，dp[i][j]表示第一个序列前i个元素和第二个序列前j个元素的最优...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值