2020.7.19 区间dp阶段测试

打崩了……

事先说明，今天没有很在状态，所以题解就直接写在代码注释里的，非常抱歉

T1 颜色联通块

此题有争议，建议跳过

题目描述

N 个方块排成一排，第 i 个颜色为 Ci 。定义一个颜色联通块 [l,r] 当且仅当 l 和 r 之间（包括l，r）所有方块的颜色相同。 例如 [3,3,3] 有 1 个颜色联通块，[5,2,4,4] 有 3 个颜色联通块。 现在你可以选定一个起始位置 p ，每次将 p 所在颜色联通块的所有方块颜色改成另一种。这个操作可能将两个颜色联通块合并成一个。问最少需要多少步，能让 [1,n] 变成一个颜色联通块。

• 输入格式
  
  输入的第一行包含一个正整数 N，（1 <= N <= 5000）代表方块的个数。
  
  输入的第二行包含 N 个正整数，分别代表每一个方块的颜色。

• 输出格式
  
  输出最少的步数。

样例1输入

4
5 2 2 1

样例1输出

2

样例2输入

8
4 5 2 2 1 3 5 5

样例2输出

4

样例3输入

1
4

样例3输出

0

---

分析

这道题。。。实话说题意特别的玄学

乍一看好像和删除字符串特别的像

只是不用删除全部，而是变成一样即可，所以在最后答案减一

于是就有了第一次尝试

// 删除字符串题解
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 5005;
int dp[MAXN][MAXN];
// dp[i][j] 表示把 a[i]---a[j] 删除的最少步数
int a[MAXN];

int main() {
	freopen("flood.in", "r", stdin);
	freopen("flood.out", "w", stdout);
	// 考试时用的文件输入输出
	memset(dp, 0x3f3f3f3f, sizeof dp); // 因为dp数组需要求最小值，所以把初值赋到最大
	int n;
	scanf ("%d", &n);
	for(int i = 1; i <= n; i++) {
		scanf ("%d", &a[i]);
		dp[i][i] = 1; // 把 a[i]---a[i] 删除只需要一步
	}
	for(int len = 2; len <= n; len++) // 分阶段，枚举区间长度
		for(int i = 1; i + len - 1 <= n; i++) {
			int j = i + len - 1;
			// 求区间的左右两个端点
			if(a[i] == a[j]) { // 如果左右两个相同
				if(i + 1 == j) dp[i][j] = 1; // 且左右端点相邻，直接一起删掉
				else dp[i][j] = 1 + dp[i + 1][j - 1];
				// 否则，先删掉除了左右端点的中间部分，在一次删除左右端点
			}
			else dp[i][j] = min(1 + dp[i][j - 1], dp[i + 1][j] + 1);
			// 在先删左端点，再删右边剩余部分与先删右端点，再删左边剩余部分中取最小
			// 但不难举出反例，"1 2 2 1"
			for(int k = i + 1; k < j; k++)
			// 所以在左右端点间枚举分割点，分别利用左右两部分进行更新
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j] - 1);
			// 因为k被重复删除了，所以减一
		}
	printf("%d", dp[1][n] - 1);
	// 此题答案在删除字符串的dp[1][n]-1里
	return 0;
}

看起来好像没什么问题，对吧。 我考场上也是这么想的

但看一下数据范围，以及我们的时间复杂度

用 N^3 的算法跑 N <= 5000 的数据 ？？！？！

果不其然，TLE0。所以你是不是以为我会讲优化方式？hhhhh 其实我们题意都理解错了。。。

这道题的 P 在第一次确定之后就不能移动位置了！！

这才是样例一的正确解释

[5 2 2 1] -> [5 5 5 1] -> [1 1 1 1]

所以我们开始了AC尝试

AC代码

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

const int MAXN = 5005;
int dp[MAXN][MAXN];
// dp[i][j] 表示把 a[i]---a[j] 变为同样颜色的最少步数
int a[MAXN];

int main() {
//	freopen("flood.in", "r", stdin);
//	freopen("flood.out", "w", stdout);
	int n_, n = 0;
	scanf ("%d", &n_);
	for(int i = 1; i <= n_; i++) {
		scanf ("%d", &a[i]);
		if(a[i] != a[i - 1]) a[++n] = a[i]; // 将相邻的相同颜色的块压缩成一个元素
	}
	for(int len = 2; len <= n; len++) // 依然是区间dp
		for(int i = 1; i + len - 1 <= n; i++) {
			int j = i + len - 1;
			if(a[i] == a[j]) dp[i][j] = 1 + dp[i + 1][j - 1];
			// 如果左右端点相同，从中间+1进行更新
			else dp[i][j] = min(dp[i][j - 1], dp[i + 1][j]) + 1;
			// 如果不同，分两部分取最小值更新
		}
	printf("%d", dp[1][n]); // 答案在dp[1][n]中
	return 0;
}

附加一篇C2021LJS学姐的blog

“实际上这是个模板。考虑枚举长度和长度区间，区间枚举划分点，这实际上是 的。只能优化区间划分点。每次加入的话，其实是不需要枚举划分点的。把序列 unique 掉，每次加入就不会有相同的影响了。”

#include<bits/stdc++.h>
using namespace std;
int n,dp[5005][5005],a[5005],len;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;++i)	scanf("%d",&a[i]);
	len=unique(a+1,a+1+n)-a-1;
	for(int i=1;i<=len;++i)
	{
		for(int l=1,r=i+1;r<=len;++l,++r)
		{
			if(a[l]==a[r])	dp[l][r]=dp[l+1][r-1]+1;
			else	dp[l][r]=min(dp[l+1][r],dp[l][r-1])+1;
		}
	}
	printf("%d",dp[1][len]);
	return 0;
}

---

T2 分离与合体

题目描述

经过在机房里数日的切磋，LYD 从杜神牛那里学会了分离与合体，出关前，杜神牛给了他一个测试……

杜神牛造了 个区域，他们紧邻着排成一行，编号 。在每个区域里都放着一把 OI 界的金钥匙，每一把都有一定的价值，LYD 当然想得到他们了。然而杜神牛规定 LYD 不能一下子把他们全部拿走，而是每次只可以拿一把。为了尽快得到所有金钥匙，LYD 自然就用上了刚学的分离与合体特技。

一开始 LYD 可以选择 中的任何一个区域进入，我们不妨把这个区域记为 。进入后 LYD 会在 区域发生分离，从而分离成两个小 LYD。分离完成的同时会有一面墙在 区域和 区域间升起，从而把 和 阻断成两个独立的区间，并在各自区间内任选除区间末尾之外（即从 和 中选取）的任意一个区域再次发生分离，这样就有了四个小小 LYD……重复以上所叙述的分离，直到每个小 LYD 发现自己所在的区间只剩下了一个区域，那么他们就可以抱起自己梦寐以求的 OI 金钥匙。

但是 LYD 不能就分成这么多个个体存在于世界上，这些小 LYD 还会再合体，合体的小 LYD 所在区间中间的墙会消失。合体会获得 合并后所在区间左右端区域里金钥匙价值之和之前分离的时候所在区域的金钥匙价值。

例如，LYD 曾在 区间中的 号区域分离成为 和 两个区间，合并时获得的价值就是 号金钥匙价值 号金钥匙价值 号金钥匙价值。

LYD 请你编程求出最终可以获得的最大总价值，并按照分离阶段从前到后，区域从左到右的顺序，输出发生分离区域编号。若有多种方案，选择分离区域尽量靠左的方案（也可以理解为输出字典序最小的）。

例如先打印一分为二的区域，然后从左到右打印二分为四的分离区域，然后是四分为八的……

• 输入格式
  
  第一行一个正整数 第二行 个用空格分开的正整数 ，表示 区域里每把金钥匙的价值。

• 输出格式
  
  第一行一个数，表示获得的最大价值

第二行按照分离阶段从前到后，区域从左到右的顺序，输出发生分离区域编号。若有多种方案，选择分离区域尽量靠左的方案（也可以理解为输出字典序最小的）。

样例输入

7
1 2 3 4 5 6 7

样例输出

238
1 2 3 4 5 6

分析

这道题……其实输出路径的方式也很迷

考试的时候想的以dfs的顺序输出

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

const int MAXN = 305;
long long dp[MAXN][MAXN]; // dp[i][j]表示在a[i]----a[j]中能利用分离合体所得到的最大价值
int a[MAXN], n; 

void print(long long x, int l, int r); // 实现声明输出函数

int main() {
	freopen("separation.in", "r", stdin);
	freopen("separation.out", "w", stdout);
	// 考试时用的文件输入输出
	scanf ("%d", &n);
	for(int i = 1; i <= n; i++)
		scanf ("%d", &a[i]);
	for(int len = 2; len <= n; len++) // 还是区间 dp，枚举阶段
		for(int i = 1; i + len - 1 <= n; i++) {
			int j = i + len - 1;
			// 求出区间左右端点
			for(int k = i; k < j; k++) // 枚举分离的所在点
				dp[i][j] = max(dp[i][j], dp[i][k] + dp[k + 1][j] + a[k] * (a[i] + a[j]));
				// 以分离点左边加上右边，再加分离一次的价值进行更新
		}
	printf("%lld\n", dp[1][n]); // 输出答案
	print(dp[1][n], 1, n);
	return 0;
}

// 输出函数
void print(long long x, int l, int r) { // 当前阶段的值，左右端点
	if(l == r) return ; // 边界条件
	int len = r - l + 1;
	for(int i = 1; i + len - 1 <= n; i++) {
		int j = i + len - 1;
		for(int k = i; k < j; k++)
			if(dp[l][r] == dp[i][k] + dp[k + 1][j] + a[k] * (a[i] + a[j])) {
			// 因为每一阶段的dp都是由上一阶段的dp更新的，所以我们只需要倒过去查找与它值相同的
			// 就是上一阶段的分离点
				printf("%d ", k); // 输出
				print(dp[i][k], i, k);
				print(dp[k + 1][j], k + 1, j);
				// 分离点两边分别进行递归
				return ;
			}
	}
}

但在激烈的争吵，怒怼商榷中，最终得出，这道题的正解应该是利用bfs输出

也就相当于，一旦有一个分离点完全被分离，也就是说这个点上只有一个人时，就直接输出这个分离点

AC代码

#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXN = 305;
int dp[MAXN][MAXN], s[MAXN][MAXN]; // 保存dp[i][j]更新时的分离点k
int a[MAXN], n;
struct node {
	int x, y;
} st;
queue<node> q;
void bfs(); // 提前声明输出函数

int main() {
	scanf ("%d", &n);
//	printf("%d\n", n);
	for(int i = 1; i <= n; i++) {
		scanf ("%d", &a[i]);
//		printf("%d ", a[i]);
	}
	for(int len = 2; len <= n; len++) // 还是区间dp，枚举阶段
		for(int i = 1; i + len - 1 <= n; i++) {
			int j = i + len - 1;
			// 求出区间左右端点
			for(int k = i; k < j; k++) { // 枚举分离的所在点
				if(dp[i][j] < dp[i][k] + dp[k + 1][j] + a[k] * (a[i] + a[j])) {
				// 以分离点左边加上右边，再加分离一次的价值进行更新
					dp[i][j] = 	dp[i][k] + dp[k + 1][j] + a[k] * (a[i] + a[j]);
					s[i][j] = k;	// 如果更新，记录分离点
				}
			}
		}
	printf("%d\n", dp[1][n]); // 输出答案
	bfs();
	return 0;
}

// 输出函数
void bfs() {
	st.x = 1, st.y = n;
	q.push(st);
	while(!q.empty()) { // 如果队列不为空，持续输出
	    if(q.front().x == q.front().y) { //
			q.pop();
			continue;
		}
		printf("%d ", s[q.front().x][q.front().y]); // 输出队列的第一个元素
		st.x = q.front().x;
		st.y = s[q.front().x][q.front().y]; // 分离点
		q.push(st);
		st.x = s[q.front().x][q.front().y] + 1; // 分离点右边的点（题目要求从左到右
		st.y = q.front().y;
		q.push(st);
		q.pop();
	}
}

T3 括号涂色

题目描述

Petya遇到了一个关于括号序列的问题： 给定一个字符串S，它代表着正确的括号序列，即（“(”）与 （“)”）是匹配的。例如：“(())()” 和 “()”是正确的，“)()”与“(()”则不是正确的。 在正确的括号序列中，一个左边的括号一定是匹配一个右边的括号（反之亦然）

现在你需要对一个正确的括号序列做涂色操作，严格满足以下三个条件：

1、每个括号要么不涂色，要么涂红色，要么涂蓝色。

2、一对匹配的括号需要且只能将其中一个涂色。

3、相邻的括号不能涂上同一种颜色（但是可以都不涂颜色）。

求：给整个括号序列涂上颜色的方案数，答案可能比较大，对 1000000007 取模。

• 输入格式
  
  输入的第一行包含一个字符串 s，（2 <= |s| <= 700）代表一个正确的括号序列。

• 输出格式
  
  输出方案数。（对 10^9 + 7 取模）

样例1输入

(())

样例1输出

12

样例2输入

(()())

样例2输出

40

样例3输入

()

样例3输出

4

分析

这道题……考场上打了个假暴力就走了……

这其实是一个四维的dp，分别讨论区间左右端点是否匹配，然后更新

AC代码

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

const int MOD = 1000000007;
const int MAXN = 705;
char s[MAXN];
int a[MAXN], mp[MAXN], tot = 1; // 记录是否匹配的a，mp数组
long long dp[MAXN][MAXN][3][3];
//dp[l][r][u][v]表示区间l, r在括号s[l]涂u色，s[r]涂v色的涂色方案总数
//记不染色为0, 另外两种色分别为1,2
bool vis[MAXN][MAXN];

void dfs(int l, int r);

int main() {
    scanf("%s", s + 1);
    int n = strlen(s + 1);
    for(int i = 1; i <= n; i++) {
        if(s[i] == '(') a[tot++] = i;
        else mp[a[--tot]] = i;
        // 记录是否匹配
    }
    dfs(1, n);
    long long ans = 0;
    for(int u = 0; u < 3; u++)
        for(int v = 0; v < 3; v++) {
            ans += dp[1][n][u][v];
			ans %= MOD;
        }
    printf("%lld", ans);
    return 0;
}

void dfs(int l, int r) {
    if(vis[l][r] == true)
        return ;
    vis[l][r] = true;
    if(r - l == 1) {
//对于长度为2的匹配的括号，只有(1,0),(2,0),(0,1),(0,2)4种涂色方式
        dp[l][r][1][0] = 1;
		dp[l][r][2][0] = 1;
        dp[l][r][0][1] = 1;
		dp[l][r][0][2] = 1;
        return ;
    }
    if(mp[l] != r) { // 左右端点不匹配
        dfs(l, mp[l]);
		dfs(mp[l] + 1, r);
		// 分别dfs左右两边，计算更新
        for(int u = 0; u < 3; u++)
	        for(int v = 0; v < 3; v++)
		        for(int x = 0; x < 3; x++)
		     	   for(int y = 0; y < 3; y++)
		// 枚举l和r的上色情况
                        if((u != 0 || v != 0) && (u == 0 || v == 0)
						&& (v != x || v == 0 && x == 0)) {
							dp[l][r][u][y] += dp[l][mp[l]][u][v] * dp[mp[l] + 1][r][x][y];
							// 其实就相当于用它来做区间的分割点
							// 两边分别计算更新
							dp[l][r][u][y] %= MOD;
						}    	

    }
    else {
        dfs(l + 1, r - 1);
        //dfs除开左右端点的中间板块
        for(int u = 0; u < 3; u++)
	        for(int v = 0; v < 3; v++)
		        for(int x = 0; x < 3; x++)
		     	   for(int y = 0; y < 3; y++)
		// 枚举l和r的上色情况
                        if((u != 0 || v != 0) && (u == 0 || v == 0)
						&& (u != x || u + x == 0) && (v != y || v + y == 0)) {
							dp[l][r][u][v] += dp[l + 1][r - 1][x][y];
							// 除开左右端点的中间板块的涂色方案总数累加更新
							dp[l][r][u][v] %= MOD;
						}
    }
}

晚安。。。