区间dp学习、

最新推荐文章于 2023-04-15 22:58:38 发布
最新推荐文章于 2023-04-15 22:58:38 发布
阅读量240 收藏
点赞数
分类专栏： 算法學習
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sasuke__/article/details/75255316
版权

参考学习：传送门

POJ 2955

题意：给出一个由'(', ')', '[', ']'组成的字符串，现在让你找出一个子序列出来使得子序列是合法括号匹配，求出子序列的最大括号匹配。

思路：dp[i][j]代表区间[i, j] 的最大匹配，转移的话看代码吧

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

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 105;
char st[qq];
int dp[qq][qq];

int main(){
	while(scanf("%s", st) != EOF) {
		mst(dp, 0);
		if(st[0] == 'e')	break;
		int len = strlen(st);
		for(int i = 1; i < len; ++i){
			for(int j = 0, k = i; k < len; ++j, ++k){
				if((st[j] == '(' && st[k] == ')') || (st[j] == '[' && st[k] == ']')){
					dp[j][k] = dp[j + 1][k - 1] + 2;
				}
				for(int x = j; x < k; ++x) {
					dp[j][k] = max(dp[j][k], dp[j][x] + dp[x + 1][k]);
				}
			}
		}
		printf("%d\n", dp[0][len - 1]);
	}
	return 0;
}



HDU2476

题意：给出两个串A和B，可以对A串进行操作，对A的某个区间填充一个字符，问最小操作次数使A变成B串

思路：参考了网上的博客区间dp，基本思路是求空串变成B串要求的dp[i][j]，然后考虑A串

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <stack>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 105;
int dp[qq][qq];
char str1[qq], str2[qq];
int ans[qq];

int main(){
	while(scanf("%s%s", str1, str2) == 2) {
		mst(dp, 0);
		int n = strlen(str1);
		for(int i = 0; i < n; ++i) {
			for(int j = i; j < n; ++j) {
				dp[i][j] = j - i + 1;
			}
		}
		for(int i = n - 2; i >= 0; --i) {
			for(int j = i + 1; j < n; ++j) {
				dp[i][j] = dp[i + 1][j] + 1;
				for(int k = i + 1; k <= j; ++k) {
					if(str2[i] == str2[k]) {
						dp[i][j] = min(dp[i][j], dp[i + 1][k - 1] + dp[k][j]);
					}
				}
			}
		}
		for(int i = 0; i < n; ++i) {
			ans[i] = dp[0][i];
			if(str1[i] == str2[i]) {
				if(i == 0)	ans[i] = 0;
				else	ans[i] = ans[i - 1];
			}
			for(int k = 0; k < i; ++k) {
				ans[i] = min(ans[i], ans[k] + dp[k + 1][i]);
			}
		}
		printf("%d\n", ans[n - 1]);
	}
	return 0;
}


POJ1141

参考：传送门

这方法是真的巧妙，QAQ

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <stack>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 100 + 10;
int d[qq][qq], c[qq][qq] = {-1};
int len;
string st;
void Dp() {
	int i, j, k, l;
	int minx;
	for(i = 0; i < len; ++i) d[i][i] = 1;
	for(l = 1; l < len; ++l) {
		for(i = 0; i + l < len; ++i) {
			j = i + l;
			minx = d[i][i] + d[i + 1][j];
			c[i][j] = i;
			for(k = i + 1; k < j; ++k) {
				if(d[i][k] + d[k + 1][j] < minx) {
					minx = d[i][k] + d[k + 1][j];
					c[i][j] = k;
				}
			}
			d[i][j] = minx;
			if((st[i] == '(' && st[j] == ')') || (st[i] == '[' && st[j] == ']')) {
				if(d[i + 1][j - 1] < minx) {
					d[i][j] = d[i + 1][j - 1];
					c[i][j] = -1;
				}
			}
		}
	}
}

void Print(int i, int j) {
	if(i > j)	return;
	if(i == j) {
		if(st[i] == '(' || st[i] == ')')	cout << "()";
		else	cout << "[]";
	}else {
		if(c[i][j] >= 0) {
			Print(i, c[i][j]);
			Print(c[i][j] + 1, j);
		}else {
			if(st[i] == '(') {
				cout << "(";
				Print(i + 1, j - 1);
				cout << ")";
			} else {
				cout << "[";
				Print(i + 1, j - 1);
				cout << "]";
			}
		}
	}
}

int main(){
	cin >> st;
	len = st.size();
	Dp();
	Print(0, len - 1);
	cout << endl;
	return 0;
}


codeforces 149D

题意：给出一个合法的括号序列，现在有三个条件
1.每一个括号要么没有颜色，要么红色，要么蓝色

2.每一对匹配的括号中有且只有一个有颜色

3.相邻的两个括号颜色不能相同。

现在问有多少种合法的填色方法


果然还是太弱了，完全没想到dfs- - 、

参考了某位聚聚的博客才理解这种做法。

dp[l][r][i][j] 代表区间[l, r] l涂i颜色，r涂j颜色的合法方式的种数

然后匹配区间进行递归，最后由小区间更新大区间。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <stack>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 705;
LL dp[qq][qq][3][3];
int match[qq];
int Stack[qq];
char st[qq];
void Dfs(int l, int r) {
	if(l + 1 == r) {
		dp[l][r][0][1] = dp[l][r][0][2] = dp[l][r][1][0] = dp[l][r][2][0] = 1;
		return;
	}
	if(match[l] == r) {
		Dfs(l + 1, r - 1);
		for(int i = 0; i < 3; ++i) {
			for(int j = 0; j < 3; ++j) {
				if(j != 1)	dp[l][r][0][1] = (dp[l][r][0][1] + dp[l + 1][r - 1][i][j]) % MOD;
				if(j != 2)	dp[l][r][0][2] = (dp[l][r][0][2] + dp[l + 1][r - 1][i][j]) % MOD;
				if(i != 1)	dp[l][r][1][0] = (dp[l][r][1][0] + dp[l + 1][r - 1][i][j]) % MOD;
				if(i != 2)	dp[l][r][2][0] = (dp[l][r][2][0] + dp[l + 1][r - 1][i][j]) % MOD;
			}
		}
	} else {
		Dfs(l, match[l]);
		Dfs(match[l] + 1, r);
		for(int i = 0; i < 3; ++i) {
			for(int j = 0; j < 3; ++j) {
				for(int k = 0; k < 3; ++k) {
					for(int h = 0; h < 3; ++h) {
						if(j && j == k)	continue;
						dp[l][r][i][h] = (dp[l][r][i][h] + (dp[l][match[l]][i][j] * dp[match[l] + 1][r][k][h] % MOD + MOD) % MOD) % MOD;
					}
				}
			}
		}
	}
}

int main(){
	scanf("%s", st + 1);
	int len = strlen(st + 1);
	int top = 0;
	for(int i = 1; i <= len; ++i) {
		if(st[i] == '(') {
			Stack[top++] = i;
		} else {
			match[Stack[--top]] = i;
		}
	}
	mst(dp, 0);
	Dfs(1, len);
	LL ans = 0;
	for(int i = 0; i < 3; ++i) {
		for(int j = 0; j < 3; ++j) {
			ans = ((ans + dp[1][len][i][j]) % MOD + MOD) % MOD;
		}
	}
	printf("%lld\n", ans);
	return 0;
}



HDU 4283

题意：n个人排成一队，现在要让他们上场表演，每个人有一个Di值，如果第i个人第k个上场，那么这个人会产生怨气(k - 1) × Di，现在由一个小黑屋，是一个栈的结构，然后可以利用这个栈调整人的出场顺序，问产生的最少怨气值是多少

思路：dp[i][j]，只考虑区间[i, j]人出场顺序时的最小怨气值，无论前面有多少人不管，i这个人可能第一个出场，也可能第j - i + 1个出场， 我们考虑i第k个出场，那么我们可以明确知道i后面k - 1个人一定是先上场的，然后i上场，剩余的再上场，就有子问题 dp[i + 1][i + k - 1] 这些人是前k - 1个上场，i第k个上场 产生的怨气(k - 1) * val[i]， dp[i + k][j]这些人是后k个上场，但实际上dp[i + k][j]这个值只考虑了区间[i + k, j]的人上场顺序的最小值，但实际前面已经有k个人上场了，所以会产生(sum[j] - sum[i + k - 1]) * k的怨气值。

比如答案中第一个人是第k个上场，那么区间[2, k]的人是前k个上场的，这几个人上场顺序的最小值就是dp[2][k]，也说明区间[k + 1, n]的人是再前k个人上场完再上场的但是dp[k + 1][n]仅仅只算了这(n - (k + 1) + 1)的上场顺序的最优怨气值，所以得加上k * (sum[n] - sum[k]).

#include <bits/stdc++.h>

using namespace std;
#define LL long long
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int INF = 2e9;
const int qq = 2e5 + 10;
int dp[205][205];
int val[205], sum[205];

int main(){
	int n, t, Cas = 0;
	scanf("%d", &t);
	while(t--) {
		scanf("%d", &n);
		sum[0] = 0;
		for(int i = 1; i <= n; ++i) {
			scanf("%d", val + i);
			sum[i] = sum[i - 1] + val[i];
		}
		mst(dp, 0);
		for(int i = 1; i <= n; ++i)
			for(int j = i + 1; j <= n; ++j)
				dp[i][j] = INF;
		for(int l = 1; l <= n - 1; ++l) {
			for(int i = 1; i <= n - 1; ++i) {
				int j = i + l;
				for(int k = 1; k <= j - i + 1; ++k) {
					dp[i][j] = min(dp[i][j], dp[i + 1][i + k - 1] + dp[i + k][j] + k * (sum[j] - sum[i + k - 1]) + val[i] * (k - 1));
				}
			}
		}
		printf("Case #%d: %d\n", ++Cas, dp[1][n]);
	}
	return 0;
}



ZOJ 3541

题意：n个按钮，每个按钮有一个值Ti，代表在你按下这个按钮后Ti后这个按钮会弹上来，然后给出n个按钮的在坐标轴上的位置，问你能否有一种方案使得所有按钮都是down的状态。

思路：这题首先有一个结论，对于某个区间[i, j]， 他一定是从左或者从右边开始按的，dp[i][j][0/1]代表区间[i, j] 从左向右按/右向左按所需的最短距离。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <stack>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define pill pair<int, int>
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 2e5 + 10;
const int INF = 1 << 30;
int dp[205][205][2], t[205], d[205], next[205][205][2];

int main(){
	int n;
	while(scanf("%d", &n) != EOF) {
		for(int i = 1; i <= n; ++i) {
			scanf("%d", t + i);
		}
		for(int i = 1; i <= n; ++i) {
			scanf("%d", d + i);
		}
		mst(dp, 0);
		for(int  l = 1; l < n; ++l) {
			for(int i = 1; i + l <= n; ++i) {
				int j = i + l;
				dp[i][j][0] = min(dp[i + 1][j][0] + d[i + 1] - d[i], dp[i + 1][j][1] + d[j] - d[i]);
				next[i][j][0] = (dp[i + 1][j][0] + d[i + 1] - d[i] >= dp[i + 1][j][1] + d[j] - d[i]);
				if(dp[i][j][0] >= t[i] || dp[i][j][0] > INF)
					dp[i][j][0] = INF;
				dp[i][j][1] = min(dp[i][j - 1][1] + d[j] - d[j - 1], dp[i][j - 1][0] + d[j] - d[i]);
				next[i][j][1] = (dp[i][j - 1][1] + d[j] - d[j - 1] <= dp[i][j - 1][0] + d[j] - d[i]);
				if(dp[i][j][1] >= t[j] || dp[i][j][1] > INF)
					dp[i][j][1] = INF;
			}
		}
/*		for(int l = 1; l < n; ++l) {
			for(int i = 1; i + l <= n; ++i) {
				int j = i + l;
				printf("%d %d %d %d\n", i, j, dp[i][j][0], dp[i][j][1]);
			}
		}*/
		int l, r, m;
		if(dp[1][n][0] < INF) {
			l = 2, r = n, m = next[1][n][0];
			printf("1");
		} else if(dp[1][n][1] < INF){
			l = 1, r = n - 1, m = next[1][n][1];
			printf("%d", n);
		} else {
			printf("Mission Impossible");
			l = 1, r = -1;
		}
		while(l <= r) {
			if(m == 0) {
				printf(" %d", l);
				m = next[l][r][m];
				l++;
			} else {
				printf(" %d", r);
				m = next[l][r][m];
				r--;
			}
		}
		puts("");
	}
	return 0;
}


Yokile_
关注
专栏目录
整数划分(区间dp)
Zsss的博客
07-13 1266
题目链接：点这里！！！！ 题意：给出两个整数 n , m ,要求在 n 中加入m - 1 个乘号，将n分成m段，求出这m段的最大乘积。(1 题解： 1、设dp[i][j][k]为区间[i,j]中乘号数目为k的最大乘积。 2、注意两两合并的时候合并为dp[i][j][0]的时候，直接合并成了一个整数没有乘号。 3、两两合并的时候合并为dp[i][j][k](k!=0)的时候
区间DP学习总结
qq_51470583的博客
04-25 240
区间dp 区间dp主要是把一个大区间分成几个小区间，先求每个小区间的最优解，然后合并求出大区间的解。 区间dp的基本形式 for(l=2; l<=n; l++)//枚举区间的长度 { for(i=1,j=l; j<=2*n; i++,j++)//确认区间的具体始末 { for(k=i; k<j; k++)//划分区间为dp[i][k]和dp[k+1][j]两部分 { //具体实现代码，状态转移方程 } } } 基本例题
区间DP入门
我们都有光明的未来
03-14 296
本篇目录： （没有超链接~） 1.入门区间DP：石子合并 2.环形区间DP的处理：环形石子合并，能量项链 3.高精度区间DP：凸多边形的划分 4.一般解法总结 前言：区间DP也是线性DP的一个重要分支，他往往以区间作为“阶段”，以划分区间的方法作为“决策”。 入门区间DP：石子合并 题目描述： 设有N堆沙子排成一排，其编号为1，2，3，…，N1，2，3，\dots ，N1，2，3，…，N（N≤30...
区间DP入门学习
loving coding
05-09 799
区间DP，区间上做动态规划。一个大区间必然由长度不等的小区间合并而来，在合并过程中，最基本也是动态规划的必须原则：满足最优化原理和无后效性原则，所以在确定状态转移方程时，得特别留心这两点。区间DP区别于其它线性DP题的特点是：区间DP通过枚举区间分界点实现状态转移。词穷了，还是写题来感受吧~~，有坑自己再补上。入门题1：凸多边形三角划分题意：给定一个具有N（N&lt;=50）个顶点的凸多边形，每个...
区间dp的总结
weixin_43688483的博客
09-01 790
1、区间dp含义 区间dp 常用dp[i][j] 来表示，含义是在区间[i,j]之间最大的…或是否可以成功。这里提供以下三个题来熟悉区间dp。 2、经典区间dp问题，合并果子  现在设有n堆的果子，每堆果子根据果子数量的不同需要耗费不同的体力，现在想把这些果子有次序的合并为一堆，消耗的体力等于两堆果子的重量之和。现在求耗费的最小的体力数多少。 比如 5 8 9 3 5+8=13 消费13体力 13 9 3 9+3=12 消费12体力 13 12 13+12=25 消费25体力 总体力消耗为 13
区间dp（入门）
qq_42757965的博客
07-29 404
这个区间dp学完dp就先告一段落了。虽然感觉dp还是啥都不会吧，但是比以前强了那么一点点，至少现在听见那希望名字知道是干什么用的了，这次我们简单的说一下区间dp。 顾名思义：区间dp就是在区间上进行动态规划，求解一段区间上的最优解。主要是通过合并小区间的 最优解进而得出整个大区间上最优解的dp算法。 既然让我求解在一个区间上的最优解，那么我把这个区间分割成一个个小区间，求解每个小区间的最优解，...
区间DP解析超详细版！！街边老奶奶也喜欢看的好博客
F.SIG的博客
10-24 987
区间DP解析超详细版！！ 概念入门 价值与代价的组合嵌套成背包中状态，而区间DP，则是需要子区间的更迭，环环相扣由子区间之间的组合来组成父区间的值，通过级级解决区间的合并问题来得出最优值
请生成一篇关于区间DP的学习笔记
最新发布
06-12
好的，以下是一篇关于区间DP的学习笔记，希望对你有所帮助。 ### 什么是区间DP 区间 DP 是一种动态规划算法，用于解决一些区间上的问题。具体来说，区间 DP 通常用于解决如下问题： - 最长公共子序列（LCS） - ...
算法基础复盘笔记Day11【动态规划】—— 区间DP、计数类DP、树形DP、记忆化搜索
Java技术一点通
04-15 2004
考虑一颗以u为根节点的子树，这颗子树的快乐指数应该是u的函数，并且分两种情况：选u和不选u。状态表示： f[u][1]表示以u 为根节点的子树并且包括u的总快乐指数，f[u][0] 表示以u为根节点的子树并且不包括u的总快乐指数。 状态计算：记点u的子节点是s - 选 $u$，f[u][1] += $\sum\limits_{}^{}$f[s][0]; - 不选 $u$，f[u][0] += $\sum\limits_{}
算法-动态规划- 区间 DP（包含源程序）.rar
09-16
在这个名为“算法-动态规划-区间DP（包含源程序）.rar”的压缩包中，我们可以期待找到关于动态规划，特别是区间动态规划的一些理论解释、实例分析以及可能的源代码实现。 区间动态规划，顾名思义，是动态规划的一个...
序列型DP
海角的孤星
01-19 348
1.拦截导弹 （NOIP1999提高组） 2.线段覆盖2（CodeVS3027）
HDU4283：区间DP
FlyingJack
04-12 208
HDU4283 题意： 第k出场的嘉宾会有(k-1)*d的不满意度。 所以为了让不满意度最小，改变出场顺序，让嘉宾进入黑屋子。 第一个进入的是最后一个出去（堆栈）。 题解 dp[i][j]表示第i到第j个嘉宾都出场了的最优情况。 只有前面的区间才会对后面的区间产生影响，影响为前面区间的人数 * 后面区间的屌丝值总和。所以要保证每个区间最优，再合并。 如果在区间[i,j]，i是第k个出...
区间DP总结
weixin_30438813的博客
04-07 273
做了几题区间动态规划的题目，觉得区间动态规划的题目是有点难的。区间DP大概是这一类的动态规划，在一个线性的数据上对区间进行状态转移，dp[i][j]表示i到j的区间。dp[i][j]可以由子区间的状态转移而来，关键是dp[i][j]表示的是什么，然后去找dp[i][j]和子区间的关系。要知道，在求dp[i][j]之前，i到j之间的子区间都已经求出来最优解。 一点一点说吧！ 首...
动态规划入门（九） 区间DP
热门推荐
Hello World!
05-03 5万+
顾名思义，区间dp就是在区间上进行动态规划，求解一段区间上的最优解；该问题的求解思路主要是通过合并小区间的最优解进而得出整个大区间上最优解的dp算法。
定义区间DP
Yukar_syt的专栏
05-12 1141
区间动态规划问题一般都是考虑，对于每段区间，他们的最优值都是由几段更小区间的最优值得到，是分治思想的一种应用，将一个区间问题不断划分为更小的区间直至一个元素组成的区间，枚举他们的组合 ，求合并后的最优值。 设F[i,j]（1 最小区间F[i,i]=0（一个数字无法合并，∴代价为0） 每次用变量k（i For p:=1 to n do // p是区间长度，作为阶段。  for i:=1
区间DP小结(附经典例题)
Dust_heart的博客
08-13 2万+
——这篇文章主要想总结下区间DP的经典题目，同时给自己复习巩固这方面知识点。 区间DP 一、定义 区间DP，顾名思义是在区间上DP，它的主要思想就是先在小区间进行DP得到最优解，然后再利用小区间的最优解合并求大区间的最优解。 二、实现思路 下面给出区间DP最简单形式的伪代码(具体要根据题目修改) //mst(dp,0) 初始化DP数组 for......
cin.tie(0) ios::sync_with_stdio(0) 同步关闭加速cin读入
傻傻分不清、
09-18 5337
HDU 6208 关闭同步之后cin得到加速 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespac
圖的強聯通分量算法
傻傻分不清、
02-17 2553
Tarjan:              學習資料:傳送門              通俗易懂版:傳送門 kosaraju:               傳送門     POJ 2186 题意：A认为B厉害， B认为C厉害， 则A认为C厉害， 求有多少个牛被其他n-1个牛都认为厉害 首先给定的图没有保证一定连通、所以我们开始处理是不是有多个连通块、 如果只有一个连通块那么缩点...
关于1到n所有数的lcm、
傻傻分不清、
04-10 1835
首先我们来求一个简单的n的范围是1 &lt;= n &lt;= 1e5，答案去模一个数一个很简单的思想就是对1到n内直接做一次lcm，但答案会超过long long，取模条件下是不对的所以我们考虑分解一下，对于x、y两个数求lcm 等于 x / gcd(x,y) * y，当我们将x、y进行素数分解后，我们可以知道gcd(x, y)实际就是 x的素数 并 y的素数，我们可以假设某个素数在x中有a个 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值