【动态规划记忆化搜索】JZOJ_6287 扭动的树

最新推荐文章于 2021-11-16 19:42:11 发布

原创最新推荐文章于 2021-11-16 19:42:11 发布 · 325 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#记忆化搜索 #动态规划 #BST #二叉查找树

动态规划专栏收录该内容

94 篇文章

订阅专栏

本文介绍了一种解决特定BST（二叉搜索树）问题的算法，目标是在满足节点间最大公约数（GCD）不为1的条件下，通过枚举和递归策略构建树，以实现子树值的最大化求和。

题意

给出 $n$ 个节点 $< k e y, v a l >$ ，其中键值为 $k e y$ ，权值为 $v a l$ ，用它们建一颗 $B S T$ ，且保证任意一条边的两个节点的 $g c d$ 不为 $1$ 。

定义某个节点的 $s u m$ 为其子树中所有 $v a l$ 的和。

最大化 $s u m$ ，不存在这颗树输出- $1$ 。

思路

对于 $B S T$ ，根据其性质把 $k e y$ 排序，那就为这颗树的中序遍历了。

枚举一个点作为根，在中序遍历中把区间分成两部分，左边代表左儿子，右边代表右儿子，再从中选出一个节点与根连接，判断是否可行 $（ g c d$ 不为 $1 ）$ ，更新答案。

利用递归处理，并记忆化剪枝。时间复杂度 $O(n^3)$

代码

#include<cstdio>
#include<algorithm>
#define file(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)

struct node {
	long long key, val;
}p[301];

int n;
long long ans;
int pre[301], gcd[302][302];
long long f[302][302][2];

bool operator <(const node &a, const node &b) {
	return a.key < b.key;
}

void dp(int l, int r, int s) {
	if (l > r || f[l][r][s]) return;
	int root = s ? l - 1 : r + 1;
	for (int i = l; i <= r; i++) {
		if (gcd[root][i] == 1) continue;
		dp(l, i - 1, 0);
		dp(i + 1, r, 1);
		if (f[l][i - 1][0] < 0 || f[i + 1][r][1] < 0) continue;
		f[l][r][s] = std::max(f[l][r][s], f[l][i - 1][0] + f[i + 1][r][1] + pre[r] - pre[l - 1]);
	}
	if (!f[l][r][s]) f[l][r][s] = -1;
}

int main() {
	file(tree);
	scanf("%d", &n);
	for (int i = 1; i <= n; i++)
		scanf("%lld %d", &p[i].key, &p[i].val);
	std::sort(p + 1, p + n + 1);
	for (int i = 1; i <= n; i++) {
		pre[i] = pre[i - 1] + p[i].val;
		for (int j = i + 1; j <= n; j++)
			gcd[i][j] = gcd[j][i] = std::__gcd(p[i].key, p[j].key);		
	}
	ans = -1;
	for (int i = 1; i <= n; i++) {
		dp(1, i - 1, 0);
		dp(i + 1, n, 1);
		if (f[1][i - 1][0] < 0 || f[i + 1][n][1] < 0) continue;
		ans = std::max(ans, f[1][i - 1][0] + f[i + 1][n][1] + pre[n]);
	}
	printf("%lld", ans);
}